Comment obtenir des objets aléatoires à partir d'un flux

Je pense que la façon la plus élégante est d'avoir un collecteur spécial.

Je suis assez sûr que la seule façon vous pouvez garantir que chaque élément a une chance égale d'être choisi, est de collecter, shuffle et re-stream. Cela peut être fait facilement à l'aide intégrée dans les Collecteurs.collectingAndThen(...) helper.

Tri par hasard comparateur ou à l'aide de randomisée réducteur, comme l'a suggéré sur certains autres réponses, va entraîner très biaisée de l'aléatoire.

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

Vous pouvez déplacer brassage collecteur à une fonction d'assistance:

public class CollectorUtils {

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

}

Je suppose que vous êtes à la recherche d'un moyen de bien s'intégrer avec les autres fonctions de traitement de flux. Donc suivant simplement la solution n'est pas ce que vous cherchez 🙂

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

Voici une solution je suis venu avec ce qui semble être différente de toutes les autres, alors je me suis dit pourquoi ne pas ajouter à la pile.

Fondamentalement, il fonctionne en utilisant le même genre de truc qu'une itération de Collections.shuffle chaque fois que vous demandez à l'élément suivant - choisir un élément aléatoire, swap de cet élément avec le premier de la liste, déplacez le pointeur vers l'avant. Pourrait aussi le faire avec le pointeur en commençant par la fin.

Le problème, c'est qu'il ne fait muter la liste que vous avez passé, mais je suppose que vous pouvez simplement prendre une copie que la première chose si vous n'aimez pas ça. Nous étions plus intéressés par la réduction des copies redondantes.

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

La réponse est très simple(avec stream):

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

Vous pouvez tester:

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