Wie konvertiere ich einen Java 8 Stream in ein Array?

Was ist der einfachste / kürzeste Weg, um Java 8 Streamin ein Array zu konvertieren ?

Die einfachste Methode besteht darin, die toArray(IntFunction<A[]> generator)Methode mit einer Array-Konstruktorreferenz zu verwenden. Dies wird in der API-Dokumentation für die Methode vorgeschlagen .

String[] stringArray = stringStream.toArray(String[]::new);

Es wird eine Methode gefunden, die eine Ganzzahl (die Größe) als Argument verwendet und a zurückgibt String[], was genau das ist, was (eine der Überladungen von) new String[]tut.

Sie können auch Ihre eigenen schreiben IntFunction:

Stream<String> stringStream = ...;
String[] stringArray = stringStream.toArray(size -> new String[size]);

Der Zweck von IntFunction<A[]> generatorist das Konvertieren einer Ganzzahl, der Größe des Arrays, in ein neues Array.

Beispielcode:

Stream<String> stringStream = Stream.of("a", "b", "c");
String[] stringArray = stringStream.toArray(size -> new String[size]);
Arrays.stream(stringArray).forEach(System.out::println);

Drucke:

a
b
c

Wenn Sie ein Array von Ints mit den Werten 1 bis 10 aus einem Stream abrufen möchten, steht Ihnen IntStream zur Verfügung.

Hier erstellen wir einen Stream mit einer Stream.of-Methode und konvertieren einen Stream mithilfe von mapToInt in einen IntStream. Dann können wir die toArray-Methode von IntStream aufrufen.

Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
//or use this to create our stream 
//Stream<Integer> stream = IntStream.rangeClosed(1, 10).boxed();
int[] array =  stream.mapToInt(x -> x).toArray();

Hier ist das Gleiche ohne den Stream, der nur den IntStream verwendet

int[]array2 =  IntStream.rangeClosed(1, 10).toArray();

Mit diesem einfachen Codeblock können Sie einen Java 8-Stream in ein Array konvertieren:

 String[] myNewArray3 = myNewStream.toArray(String[]::new);

Aber lassen Sie uns die Dinge näher erläutern. Lassen Sie uns zunächst eine Liste von Zeichenfolgen erstellen, die mit drei Werten gefüllt sind:

String[] stringList = {"Bachiri","Taoufiq","Abderrahman"};

Erstellen Sie einen Stream aus dem angegebenen Array:

Stream<String> stringStream = Arrays.stream(stringList);

Wir können jetzt einige Operationen an diesem Stream ausführen.

Stream<String> myNewStream = stringStream.map(s -> s.toUpperCase());

und konvertieren Sie es schließlich mit den folgenden Methoden in ein Java 8-Array:

1-Klassische Methode (Funktionsschnittstelle)

IntFunction<String[]> intFunction = new IntFunction<String[]>() {
    @Override
    public String[] apply(int value) {
        return new String[value];
    }
};


String[] myNewArray = myNewStream.toArray(intFunction);

2-Lambda-Ausdruck

 String[] myNewArray2 = myNewStream.toArray(value -> new String[value]);

3- Methodenreferenz

String[] myNewArray3 = myNewStream.toArray(String[]::new);

Methodenreferenz Erläuterung:

Es ist eine andere Art, einen Lambda-Ausdruck zu schreiben, der dem anderen genau entspricht.

Konvertieren Sie Text in ein Zeichenfolgenarray, in dem jeder Wert durch Komma getrennt wird, und schneiden Sie jedes Feld ab. Beispiel:

String[] stringArray = Arrays.stream(line.split(",")).map(String::trim).toArray(String[]::new);

Sie können einen benutzerdefinierten Kollektor erstellen, der einen Stream in ein Array konvertiert.

public static <T> Collector<T, ?, T[]> toArray( IntFunction<T[]> converter )
{
    return Collectors.collectingAndThen( 
                  Collectors.toList(), 
                  list ->list.toArray( converter.apply( list.size() ) ) );
}

und eine schnelle Verwendung

List<String> input = Arrays.asList( ..... );

String[] result = input.stream().
         .collect( CustomCollectors.**toArray**( String[]::new ) );

Die Verwendung der toArray(IntFunction<A[]> generator)Methode ist in der Tat eine sehr elegante und sichere Methode, um einen Stream in ein Array des gleichen Stream-Typs zu konvertieren (oder genauer gesagt zu sammeln).

Wenn der Typ des zurückgegebenen Arrays jedoch nicht wichtig ist, ist die einfache Verwendung der toArray()Methode sowohl einfacher als auch kürzer. Zum Beispiel:

    Stream<Object> args = Stream.of(BigDecimal.ONE, "Two", 3);
    System.out.printf("%s, %s, %s!", args.toArray());

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

int[] arr=   stream.mapToInt(x->x.intValue()).toArray();

import java.util.List;
import java.util.stream.Stream;

class Main {

    public static void main(String[] args) {
        // Create a stream of strings from list of strings
        Stream<String> myStreamOfStrings = List.of("lala", "foo", "bar").stream();

        // Convert stream to array by using toArray method
        String[] myArrayOfStrings = myStreamOfStrings.toArray(String[]::new);

        // Print results
        for (String string : myArrayOfStrings) {
            System.out.println(string);
        }
    }
}

Probieren Sie es online aus: https://repl.it/@SmaMa/Stream-to-array

     Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

     Integer[] integers = stream.toArray(it->new Integer[it]);

Sie können dies auf verschiedene Arten tun. Alle Möglichkeiten sind technisch gleich, aber die Verwendung von Lambda würde einen Teil des Codes vereinfachen. Nehmen wir an, wir initialisieren eine Liste zuerst mit String und nennen sie Personen.

List<String> persons = new ArrayList<String>(){{add("a"); add("b"); add("c");}};
Stream<String> stream = persons.stream();

Jetzt können Sie eine der folgenden Möglichkeiten verwenden.

1. Verwenden des Lambda-Ausdrucks zum Erstellen eines neuen StringArray mit definierter Größe.

   String [] stringArray = stream.toArray (Größe-> neuer String [Größe]);

2. Verwenden Sie die Methodenreferenz direkt.

   String [] stringArray = stream.toArray (String [] :: new);