Как получить случайные объекты из потока

Ответ 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;
}

Ответ 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)

Ответ 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);
}

Ответ 4

Попробуйте что-то вроде этого:

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

Ответ 5

Ответ очень прост (с потоком):

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

Ответ 6

Это однолинейное решение:

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

RandomUtils - это общие права 3