Schnelle Möglichkeit zum Erstellen einer zufälligen Teilmenge eines Arrays mit IntStream

Question

Ich frage mich, ob IntStream und Lambdas irgendwie schnell verwendet werden können (one-line) erstellen Sie ein Array mit einer zufälligen Teilmenge eines vorhandenen Array von Elementen.

Zum Beispiel sagen, dass ich einen Pool von Spielern haben:

Player[] allPlayers; 

Und ich möchte eine zufällige Teilmenge dieser Spieler bekommen, die Dimension der erforderlichen Teilmenge gegeben. Traditionell würde ich so etwas wie tun:

List<Player> players = new ArrayList<Player>(Arrays.asList(allPlayers)); 

int subsetSize = 8; 
Player[] subset = new Player[subsetSize]; 
for (int i = 0; i < subsetSize; i++) { 
    int randIndex = new Random().nextInt(players.size()); 
    subset[i] = players[randIndex]; 

    players.remove(randIndex); 
} 

return subset; 

Aber kann dieser Prozess mit Java 8 Funktionen getan werden? Ich nehme an, es würde es verdichten, was ich versuche zu erreichen. Ich bekomme immer noch den Dreh raus mit diesen neuen Java 8 Features, wie IntStream und Lambdas und ich würde nicht wissen, wie man sie für diesen speziellen Fall benutzt.

Answer 1

In diesem Fall möchten Sie streamSize unterschiedliche Elemente aus einer Eingabe-Array auszuwählen.

können Sie die Random#ints(randomNumberOrigin, randomNumberBound) Methode verwenden:

Gibt einen effektiv unbegrenzten Strom von Pseudo-Zufalls-int-Werten, die jeweils entsprechen, an die angegebenen Herkunft (einschließlich) und gebunden (exklusiv).

Dies gibt einen Stream von zufälligen Ganzzahlen im angegebenen Bereich zurück. Um eindeutige Werte zu gewährleisten, wird distinct() aufgerufen und limit(...) ermöglicht nur die Anzahl der Elemente, die wir wollen, zu behalten.

Random random = new Random(); 
Player[] subset = random.ints(0, allPlayers.length) 
         .distinct() 
         .limit(subsetSize) 
         .mapToObj(i -> allPlayers[i]) 
         .toArray(Player[]::new); 

Ich würde jedoch zu beachten, dass, auch wenn dies ein Einzeiler, es ist nicht so effizient wie JB Nizet's solution ist, da diese Zahlen zu erzeugen werden fortgesetzt, bis ein deutlicher gefunden ist.

Answer 2

Sie könnten folgendes verwenden, das keinen Stream verwendet, kein One-Liner ist, aber bereits mehr kondensiert.

List<Player> copy = new ArrayList<>(Arrays.asList(allPlayers)); 
Collections.shuffle(copy); 
return copy.subList(0, subsetSize).toArray(new Player[0]); 

Answer 3

Ein effizienter Weg, dies zu tun ist:

List<String> players = Arrays.asList("a", "b", "c", "d", "e"); 
int subsetSize = 3; 
for (int i = 0; i < subsetSize; i++) 
    Collections.swap(players, i, ThreadLocalRandom.current().nextInt(i, players.size())); 
System.out.println(players.subList(0, subsetSize)); 

Dies gilt nicht eine ineffiziente Suche nach nicht verwendeten Indizes verlangen, wenn subsetSize groß ist. Es erfordert keinen Aufruf shuffle auf der gesamten Liste, so ist geeigneter, wenn subsetSize ist klein. Es vermeidet auch den Aufruf ArrayList.remove, der lineare Zeitkomplexität hat.

Dieser Code verwendet keine Stream Operationen, aber ich denke nicht, dass es möglich ist, eine einfache, effiziente Lösung mit Stream zu schreiben, ohne ein Lambda zu verwenden, das den Status ändert (schlechte Vorgehensweise).