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提供了一些返回流的方法。例如，int（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());

您可以将该shuffling收集器移动到辅助函数：

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

我提出的解决方案似乎与其他解决方案不同，所以我想为什么不把它添加到堆中。

基本上，每当你要求下一个元素时，它使用与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 4

这是我的一线解决方案：

 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 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

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

没有直接的方法可以从当前的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 7

答案非常简单（有流）：

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);

如何从流中获取随机对象

7 个答案: