如何从流中获取随机对象

Question

假设我有一个单词列表，我想创建一个方法，它将新列表的大小作为参数并返回新列表。如何从原始 sourceList 中获取随机单词？

public List<String> createList(int listSize) {
   Random rand = new Random();
   List<String> wordList = sourceWords.
      stream().
      limit(listSize).
      collect(Collectors.toList()); 

   return wordList;
}

那么如何以及在哪里可以使用我的 Random？

Answer 1

我找到了合适的解决方案。 Random 提供了一些返回流的方法。例如 ints(size) 创建一个随机整数流。

public List<String> createList(int listSize)
{
   Random rand = new Random();
   List<String> wordList = rand.
      ints(listSize, 0, sourceWords.size()).
      mapToObj(i -> sourceWords.get(i)).
      collect(Collectors.toList());

   return wordList;
}

Answer 2

我认为最优雅的方式是拥有一个特殊的收藏家。

我很确定，唯一能保证每件物品都有同等机会被选中的方法是收集、洗牌和重新播放。这可以使用内置的 Collectors.collectingAndThen(...) 助手轻松完成。

通过随机比较器或使用随机化简器进行排序，就像其他一些答案所建议的那样，会导致非常有偏差的随机性。

List<String> wordList = sourceWords.stream()
  .collect(Collectors.collectingAndThen(Collectors.toList(), collected -> {
      Collections.shuffle(collected);
      return collected.stream();
  }))
  .limit(listSize)
  .collect(Collectors.toList());

您可以将该洗牌收集器移至辅助函数：

public class CollectorUtils {

    public static <T> Collector<T, ?, Stream<T>> toShuffledStream() {
        return Collectors.collectingAndThen(Collectors.toList(), collected -> {
            Collections.shuffle(collected);
            return collected.stream();
        });
    }

}

我假设您正在寻找一种与其他流处理功能完美集成的方法。因此，以下简单的解决方案不是您想要的:)

Collections.shuffle(wordList)
return wordList.subList(0, limitSize)

Answer 3

这是我的单行解决方案：

 List<String> st = Arrays.asList("aaaa","bbbb","cccc");
 st.stream().sorted((o1, o2) -> RandomUtils.nextInt(0, 2)-1).findFirst().get();

RandomUtils 来自 commons lang 3

Answer 4

这是我想出的一个解决方案，似乎与其他所有解决方案都不同，所以我想为什么不把它加到一堆。

基本上，每次您请求下一个元素时，它使用与Collections.shuffle 的一次迭代相同的技巧来工作 - 选择一个随机元素，将该元素与列表中的第一个元素交换，向前移动指针。也可以通过指针从末尾倒数来做到这一点。

需要注意的是，它确实会改变您传入的列表，但我想如果您不喜欢这样，您可以先复制一份。我们对减少冗余副本更感兴趣。

private static <T> Stream<T> randomStream(List<T> list)
{
    int characteristics = Spliterator.SIZED;
    // If you know your list is also unique / immutable / non-null
    //int characteristics = Spliterator.DISTINCT | Spliterator.IMMUTABLE | Spliterator.NONNULL | Spliterator.SIZED;
    Spliterator<T> spliterator = new Spliterators.AbstractSpliterator<T>(list.size(), characteristics)
    {
        private final Random random = new SecureRandom();
        private final int size = list.size();
        private int frontPointer = 0;

        @Override
        public boolean tryAdvance(Consumer<? super T> action)
        {
            if (frontPointer == size)
            {
                return false;
            }

            // Same logic as one iteration of Collections.shuffle, so people talking about it not being
            // fair randomness can take that up with the JDK project.
            int nextIndex = random.nextInt(size - frontPointer) + frontPointer;
            T nextItem = list.get(nextIndex);
            // Technically the value we end up putting into frontPointer
            // is never used again, but using swap anyway, for clarity.
            Collections.swap(list, nextIndex, frontPointer);

            frontPointer++;
            // All items from frontPointer onwards have not yet been chosen.

            action.accept(nextItem);
            return true;
        }
    };

    return StreamSupport.stream(spliterator, false);
}

Answer 5

试试这样的：

List<String> getSomeRandom(int size, List<String> sourceList) {
    List<String> copy = new ArrayList<String>(sourceList);
    Collections.shuffle(copy);
    List<String> result = new ArrayList<String>();
    for (int i = 0; i < size; i++) {
        result.add(copy.get(i));
    }

    return result;
}

Answer 6

答案很简单（带流）：

List<String> a = src.stream().sorted((o1, o2) -> {
        if (o1.equals(o2)) return 0;
        return (r.nextBoolean()) ? 1 : -1;
    }).limit(10).collect(Collectors.toList());

你可以测试一下：

List<String> src = new ArrayList<String>();
for (int i = 0; i < 20; i++) {
    src.add(String.valueOf(i*10));
}
Random r = new Random();
List<String> a = src.stream().sorted((o1, o2) -> {
        if (o1.equals(o2)) return 0;
        return (r.nextBoolean()) ? 1 : -1;
    }).limit(10).collect(Collectors.toList());
System.out.println(a);

Answer 7

如果您希望结果列表中没有重复的项目并且您的初始列表是不可变的：

• 没有直接的方法可以从当前的 Streams API 中获取它。
• 不可能使用随机比较器，因为它会破坏比较合同。

你可以试试这样的：

public List<String> getStringList(final List<String> strings, final int size) {
    if (size < 1 || size > strings.size()) {
        throw new IllegalArgumentException("Out of range size.");
    }

    final List<String> stringList = new ArrayList<>(size);

    for (int i = 0; i < size; i++) {
        getRandomString(strings, stringList)
                .ifPresent(stringList::add);
    }

    return stringList;
}

private Optional<String> getRandomString(final List<String> stringList, final List<String> excludeStringList) {
    final List<String> filteredStringList = stringList.stream()
            .filter(c -> !excludeStringList.contains(c))
            .collect(toList());

    if (filteredStringList.isEmpty()) {
        return Optional.empty();
    }

    final int randomIndex = new Random().nextInt(filteredStringList.size());
    return Optional.of(filteredStringList.get(randomIndex));
}

Answer 8

@kozla13 改进版：

List<String> st = Arrays.asList("aaaa","bbbb","cccc");
st.stream().min((o1, o2) -> o1 == o2 ? 0 : (ThreadLocalRandom.current().nextBoolean() ? -1 : 1)).orElseThrow();

1. 使用java内置类ThreadLocalRandom
2. nextInt 从序列 [-1, 0, 1] 生成一个，但在 compare func 中返回 0 意味着元素和 this 的副作用相等 - 在这种情况下将始终采用第一个元素 (o1)。
3. 正确处理对象等于大小写