web-dev-qa-db-fra.com

Comment convertir un flux Java 8 en un tableau?

Quel est le moyen le plus simple/le plus court de convertir un Java 8 Stream en un tableau?

javaarraysjava-8java-stream
701
user972946

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

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

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

Vous pouvez aussi écrire votre propre IntFunction:

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

Le but du IntFunction<A[]> generator est 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);

Impressions:

a
b
c
1073
skiwi

Si vous souhaitez obtenir un tableau d'ints, avec des valeurs comprises entre 1 et 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 à l’aide de 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 flux, en utilisant uniquement le IntStream

int[]array2 =  IntStream.rangeClosed(1, 10).toArray();
36
Ida Bucić

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

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

Mais expliquons davantage les choses, commençons par créer une liste de chaînes contenant trois valeurs:

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

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

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

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

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

et finalement le convertir en un tableau Java 8 à l'aide de 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-expression Lambda

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

3- Référence de la 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 strictement équivalente à l'autre.

13
Bachiri Taoufiq Abderrahman

Convertissez le texte en tableau de chaînes en séparant chaque valeur par une virgule et en découpant chaque champ, par exemple:

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

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 ) );
4
Thomas Pliakas

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

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

    Stream<Object> args = Stream.of(BigDecimal.ONE, "Two", 3);
    System.out.printf("%s, %s, %s!", args.toArray());
3
Kunda
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

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