Question Comment convertir un flux Java 8 en un tableau?


Quel est le moyen le plus simple / le plus court pour convertir un Java 8 Stream dans un tableau?


547
2018-04-15 09:00


origine


Réponses:


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

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

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

Vous pourriez aussi écrire votre propre IntFunction:

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

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

Exemple de code:

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

Impressions:

a
b
c

827
2018-04-15 09:07



Si vous voulez obtenir un tableau d'ints, avec des valeurs de 1 à 10, à partir d'un Stream, IntStream est à votre disposition.

Ici, nous créons une Stream avec une méthode Stream.of et convertissons un Stream en un IntStream en utilisant 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 seulement l'IntStream

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

24
2017-10-28 13:28



Vous pouvez convertir un flux java 8 en un tableau en utilisant ce simple bloc de code:

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

Mais expliquons d'abord les choses, 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 quelques 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);

Expression 2 -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 qui est strictement équivalente à l'autre.


4
2018-05-25 16:57



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

3
2018-02-16 13:18



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

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

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

2
2017-07-30 09:19



Convertir le texte en tableau de chaînes où séparer chaque valeur par une virgule, et couper chaque champ, par exemple:

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

1
2018-04-02 12:39



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

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

0
2018-04-15 08:20



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

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

0
2018-06-08 10:22



Vous pouvez le faire de plusieurs façons. Toutes les façons sont techniquement les mêmes, mais l'utilisation de Lambda simplifierait une partie du code. Supposons que nous initialisons une liste avec String, appelons-la des 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 la fonction toArray () de l'interface Stream qui renvoie un Object [], puis le convertit en String [].

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

2.Utilisation de l'expression Lambda pour créer un nouveau StringArray avec une taille définie.

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

3. En utilisant la référence de méthode directement.

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

-1
2018-05-31 08:54