Comment convertir un flux Java 8 en tableau?

Quelle est la manière la plus simple / la plus courte de convertir un Java 8 Streamen tableau?

La méthode la plus simple consiste à utiliser la toArray(IntFunction<A[]> generator)méthode avec une référence de constructeur de tableau. Ceci est suggéré dans la documentation API de la méthode .

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

Ce qu'il fait, c'est trouver une méthode qui prend un entier (la taille) comme argument, et retourne a String[], qui est exactement ce que fait (l'une des surcharges de) new String[].

Vous pouvez également écrire le vôtre IntFunction:

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

Le but de IntFunction<A[]> generatorest de convertir un entier, la taille du tableau, en un nouveau tableau.

Exemple de code:

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

Tirages:

a
b
c

Si vous souhaitez obtenir un tableau d'entiers, avec des valeurs de 1 à 10, à partir d'un flux, IntStream est à votre disposition.

Ici, nous créons un Stream avec une méthode Stream.of et convertissons un Stream en IntStream en utilisant un mapToInt. Ensuite, nous pouvons appeler la méthode toArray d'IntStream.

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

Voici la même chose, sans le Stream, en utilisant uniquement l'IntStream

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

Vous pouvez convertir un flux java 8 en un tableau à l'aide de ce simple bloc de code:

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

Mais expliquons les choses davantage, tout d'abord, créons une liste de chaînes remplies de trois valeurs:

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

Créez un flux à partir du tableau donné:

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

nous pouvons maintenant effectuer certaines opérations sur ce flux Ex:

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

et enfin le convertir en un tableau java 8 en utilisant ces méthodes:

Méthode 1-Classic (interface fonctionnelle)

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


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

2 -Lambda expression

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

3- Référence de méthode

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

Référence de la méthode Explication:

C'est une autre façon d'écrire une expression lambda qui est strictement équivalente à l'autre.

Convertissez le texte en tableau de chaînes où séparez chaque valeur par une virgule et coupez chaque champ, par exemple:

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

Vous pouvez créer un collecteur personnalisé qui convertit un flux en tableau.

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

et une utilisation rapide

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

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

L'utilisation de la toArray(IntFunction<A[]> generator)méthode est en effet un moyen très élégant et sûr de convertir (ou plus correctement, de collecter) un Stream en un tableau du même type de Stream.

Cependant, si le type du tableau retourné n'est pas important, la simple utilisation de la toArray()méthode est à la fois plus simple et plus courte. Par exemple:

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

Essayez-le en ligne: 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]);

Vous pouvez le faire de plusieurs façons. Toutes les méthodes sont techniquement les mêmes, mais l'utilisation de Lambda simplifierait une partie du code. Disons que nous initialisons d'abord une liste avec String, appelons-la personnes.

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

Vous pouvez maintenant utiliser l'une des méthodes suivantes.

1. Utilisation de Lambda Expresiion pour créer un nouveau StringArray avec une taille définie.

   String [] stringArray = stream.toArray (size-> new String [size]);

2. Utilisation directe de la référence de méthode.

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