将元素连接到列表中，并将列表映射到hashmap

Question

我编写了以下代码：

Stream
    .concat(
        _question.getIncorrectAnswers().stream(), 
        Stream.of(_question.getCorrectAnswer())
    )
    .collect(Collectors.collectingAndThen(
        Collectors.toList(), 
        collected -> {
            Collections.shuffle(collected);
            return collected.stream();
        }
    ))
    .collect(Collectors.toMap(index++, Object::toString));

我试图实现的是将_question.getCorrectAnswer() (一个String对象)连接到_question.getIncorrectAnswers() (一个字符串的List )中。

然后我想打乱我创建的列表，然后将该列表映射到以下内容：

private final Map<Integer, String> _options = new HashMap<>();

这是一个映射，其中包含一个计数器(从1开始)和列表中包含的字符串。

我想使用Java Streams来实现这一点(主要是为了教育目的)。

我知道如何使用3-4行，但我正在寻找一种更复杂的方法，这样我就可以理解和学习新的方法。

任何帮助或指导我们都将不胜感激。

Answer 1

index++附带了编译错误，请使用增量对象修复它。

AtomicInteger index = new AtomicInteger();
Object v = Stream.concat(_question.getIncorrectAnswers().stream(), Stream.of(_question.getCorrectAnswer())).collect(Collectors.collectingAndThen(Collectors.toList(), collected ->
{
    Collections.shuffle(collected);
    return collected.stream();
})).collect(Collectors.toMap(i -> index.incrementAndGet(), Object::toString));

Answer 2

以下是使用java.util.Random的一种方法

假设您有这两个方法返回一个列表和一个字符串：

static List<String> getIncorrectAnswers(){
    return List.of("bar", "baz", "doo");
}

static String getCorrectAnswer() {
    return "foo";
}

在0和getIncorrectAnswers().size() + 1之间生成随机i，将每个随机int int映射到一个字符串(如果为i == getIncorrectAnswers().size()，则将正确答案映射到索引i处的不正确答案)，最后收集到使用

collect(Supplier<R> supplier, 
        BiConsumer<R, ? super T> accumulator, 
        BiConsumer<R, R> combiner)

示例：

public static void main(String[] args) {
    Random random = new Random();
    Map<Integer, String> result = 
            random.ints(0, getIncorrectAnswers().size() + 1)
            .distinct()
            .limit(getIncorrectAnswers().size() + 1)
            .mapToObj(i -> i == getIncorrectAnswers().size() ? getCorrectAnswer() : getIncorrectAnswers().get(i))
            .collect(HashMap::new, (m, s) -> m.put(m.size() + 1, s), (m1, m2) -> {
                int offset = m1.size();
                m2.forEach((i, s) -> m1.put(i + offset, s));
            });

    result.entrySet().forEach(System.out::println);
}

Answer 3

可以使用带有自定义“比较器”的Stream::sorted来随机化顺序，而不是使用Collections.shuffle。

此外，在计算密钥时，应该使用AtomicInteger k或int[] k来递增密钥。

在下面的代码示例中，连接字符串的条目是随机排序的：

public static Map<Integer, String> buildOptions(Question question) {
    AtomicInteger k = new AtomicInteger(1);
    return Stream.concat(Stream.of(question.getCorrectAnswer()),
                         question.getIncorrectAnswers().stream())
                 .sorted((s1, s2) -> ThreadLocalRandom.current().nextInt(7) - 3)
                 .collect(Collectors.toMap(x -> k.getAndIncrement(), x -> x));
}

或者可以随机生成和排序索引序列(需要装箱，因为IntStream没有带有自定义比较器的sorted )：

public static Map<Integer, String> buildOptionsIndex(Question question) {
    int[] k = {1};
    int n = question.getIncorrectAnswers().size();
    return IntStream.rangeClosed(0, n)
            .boxed()
            .sorted((i1, i2) -> ThreadLocalRandom.current().nextInt(2 * n + 1) - n)
            .map(i -> i == n ? question.getCorrectAnswer() : question.getIncorrectAnswers().get(i))
            .collect(Collectors.toMap(s -> k[0]++, Function.identity()));
}

这些方法提供了类似的结果：

for (int i = 0; i < 3; i++) {
    System.out.println(buildOptions(new Question("good",
                                                  Arrays.asList("invalid", "poor", "misfit", "imprecise"))));
    System.out.println(buildOptionsIndex(new Question("correct",
                                                  Arrays.asList("bad", "incorrect", "wrong", "inaccurate"))));
    System.out.println("----");
}

输出

{1=invalid, 2=misfit, 3=good, 4=poor, 5=imprecise}
{1=inaccurate, 2=wrong, 3=incorrect, 4=bad, 5=correct}
----
{1=good, 2=misfit, 3=invalid, 4=poor, 5=imprecise}
{1=bad, 2=incorrect, 3=wrong, 4=correct, 5=inaccurate}
----
{1=poor, 2=misfit, 3=invalid, 4=good, 5=imprecise}
{1=bad, 2=incorrect, 3=correct, 4=wrong, 5=inaccurate}
----