Stream.flatMap, comme on peut le deviner par son nom, est la combinaison d'un map et a flat opération. Cela signifie que vous appliquez d'abord une fonction à vos éléments, puis que vous l'aplatissez. Stream.map applique uniquement une fonction au flux sans aplatir le flux.

Pour comprendre en quoi consiste l'aplatissement d'un flux, considérons une structure comme [ [1,2,3],[4,5,6],[7,8,9] ] qui a "deux niveaux". Aplatir cela signifie le transformer en une structure "à un niveau": [ 1,2,3,4,5,6,7,8,9 ].

, je voudrais donner 2 exemples pour obtenir un plus point de vue pratique:
Premier exemple d'utilisation de map:

@Test
public void convertStringToUpperCaseStreams() {
    List<String> collected = Stream.of("a", "b", "hello") // Stream of String 
            .map(String::toUpperCase) // Returns a stream consisting of the results of applying the given function to the elements of this stream.
            .collect(Collectors.toList());
    assertEquals(asList("A", "B", "HELLO"), collected);
}

Rien de spécial dans le premier exemple, un Function est appliqué pour renvoyer le String en majuscules.

Le Deuxième exemple d'utilisation de flatMap:

@Test
public void testflatMap() throws Exception {
    List<Integer> together = Stream.of(asList(1, 2), asList(3, 4)) // Stream of List<Integer>
            .flatMap(List::stream)
            .map(integer -> integer + 1)
            .collect(Collectors.toList());
    assertEquals(asList(2, 3, 4, 5), together);
}

Dans le deuxième exemple, un flux de liste est passé. Ce n'est PAS un Flux d'entier!
Si une fonction de transformation doit être utilisée (via map), alors d'abord le flux doit être aplati à autre chose (un flux d'entier).
Si flatMapest supprimé, l'erreur suivante est renvoyée: L'opérateur + n'est pas défini pour la liste des types d'arguments, int.
Il n'est PAS possible d'appliquer + 1 sur un List d'Entiers!

Veuillez parcourir le post entièrement pour avoir une idée claire,

Carte vs flatMap:

Pour renvoyer une longueur de chaque mot d'une liste, nous ferions quelque chose comme ci-dessous..

Version courte donnée ci-dessous

Lorsque nous collectons deux listes, données ci-dessous

Sans plat à la carte => [1,2],[1,1] => [[1,2],[1,1]] Ici, deux listes sont placés à l'intérieur d'une liste, de sorte que la sortie sera liste contenant listes

Avec carte plate => [1,2],[1,1] => [1,2,1,1] Ici, deux listes sont aplaties et seules les valeurs sont placées dans list, donc la sortie sera list contenant uniquement des éléments

Fondamentalement, il fusionne tous les objets dans one

# # La version détaillée a été donnée ci-dessous: -

Par exemple:-
tenir compte d'une liste ["PILE", "OOOVVVER"], et on essaye de revenir une liste comme ["STACKOVER"] (ne renvoyant que des lettres uniques de cette liste) Initialement, nous ferions quelque chose comme ci-dessous pour renvoyer une liste ["STACKOVER"] de ["STACK", "OOOVVVER"]

public class WordMap {
  public static void main(String[] args) {
    List<String> lst = Arrays.asList("STACK","OOOVER");
    lst.stream().map(w->w.split("")).distinct().collect(Collectors.toList());
  }
}

Ici, le problème est que Lambda passé à la méthode map renvoie un tableau de chaînes pour chaque mot, Donc le flux renvoyé par la méthode map est en fait de type Stream, Mais ce dont nous avons besoin, c'est Stream pour représenter un flux de caractères, l'image ci-dessous illustre le problème.

Figure A:

Vous pourriez penser que, Nous pouvons résoudre ce problème en utilisant flatmap,
OK, nous allons voir comment résoudre ce problème en utilisant map et Tableaux.flux Tout d'abord, vous allez avoir besoin d'un flux de caractères au lieu d'un flux de tableaux. Il existe une méthode appelée Tableaux.stream() qui prendrait un tableau et produirait un flux, par exemple:

String[] arrayOfWords = {"STACK", "OOOVVVER"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);
streamOfWords.map(s->s.split("")) //Converting word in to array of letters
    .map(Arrays::stream).distinct() //Make array in to separate stream
    .collect(Collectors.toList());

Ce qui précède ne fonctionne toujours pas, car nous finissons maintenant par avec une liste de flux (plus précisément, Stream>), nous devons d'abord convertir chaque mot en un tableau de lettres individuelles, puis transformer chaque tableau en un flux séparé

En utilisant flatMap nous devrions être en mesure de résoudre ce problème tant que ci-dessous:

String[] arrayOfWords = {"STACK", "OOOVVVER"};
Stream<String> streamOfWords = Arrays.stream(arrayOfWords);
streamOfWords.map(s->s.split("")) //Converting word in to array of letters
    .flatMap(Arrays::stream).distinct() //flattens each generated stream in to a single stream
    .collect(Collectors.toList());

FlatMap effectuerait le mappage de chaque tableau non pas avec le flux mais avec le contenu de ce flux. Tous les flux individuels qui seraient générés lors de l'utilisation de map(Arrays::stream) sont fusionnés en un seul flux. La figure B illustre l'effet de l'utilisation de la méthode flatMap. Comparez-le avec ce que fait la carte dans la figure A. Figure B

La méthode flatMap vous permet de remplacer chaque valeur d'un flux par un autre flux, puis de joindre tous les flux générés en un seul flux.

Une ligne de réponse: flatMap permet d'aplatir un Collection<Collection<T>> dans un Collection<T>. De la même manière, il sera également aplatir un Optional<Optional<T>> en Optional<T>.

Comme vous pouvez le voir, avec map() seulement:

• Le type intermédiaire est Stream<List<Item>>
• Le type de retour est List<List<Item>>

Et avec flatMap():

• Le type intermédiaire est Stream<Item>
• Le type de retour est List<Item>

Voici le résultat du test du code utilisé juste en dessous:

-------- Without flatMap() -------------------------------
     collect() returns: [[Laptop, Phone], [Mouse, Keyboard]]

-------- With flatMap() ----------------------------------
     collect() returns: [Laptop, Phone, Mouse, Keyboard]

Code utilisé:

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

public class Parcel {
  String name;
  List<String> items;

  public Parcel(String name, String... items) {
    this.name = name;
    this.items = Arrays.asList(items);
  }

  public List<String> getItems() {
    return items;
  }

  public static void main(String[] args) {
    Parcel amazon = new Parcel("amazon", "Laptop", "Phone");
    Parcel ebay = new Parcel("ebay", "Mouse", "Keyboard");
    List<Parcel> parcels = Arrays.asList(amazon, ebay);

    System.out.println("-------- Without flatMap() ---------------------------");
    List<List<String>> mapReturn = parcels.stream()
      .map(Parcel::getItems)
      .collect(Collectors.toList());
    System.out.println("\t collect() returns: " + mapReturn);

    System.out.println("\n-------- With flatMap() ------------------------------");
    List<String> flatMapReturn = parcels.stream()
      .map(Parcel::getItems)
      .flatMap(Collection::stream)
      .collect(Collectors.toList());
    System.out.println("\t collect() returns: " + flatMapReturn);
  }
}

La fonction que vous passez à stream.map doit retourner un objet. Cela signifie que chaque objet dans le flux d'entrée entraîne exactement un objet dans le flux de sortie.

La fonction que vous passez à stream.flatMap renvoie un flux pour chaque objet. Cela signifie que la fonction peut renvoyer n'importe quel nombre d'objets pour chaque objet entrée (y compris aucune). Les flux résultants sont ensuite concaténés en un flux de sortie.

Pour une Carte nous avons une liste d'éléments et d'une (fonction,action) f donc :

[a,b,c] f(x) => [f(a),f(b),f(c)]

Et pour la carte plate, nous avons une liste d'éléments et nous avons un (function,action) f et nous voulons que le résultat soit aplati:

[[a,b],[c,d,e]] f(x) =>[f(a),f(b),f(c),f(d),f(e)]

J'ai le sentiment que la plupart des réponses ici compliquent le problème simple. Si vous comprenez déjà comment fonctionne le map, cela devrait être assez facile à saisir.

Il y a des cas où nous pouvons nous retrouver avec des structures imbriquées indésirables lors de l'utilisation de map(), la méthode flatMap() est conçue pour surmonter cela en évitant l'emballage.

Exemples:

1

List<List<Integer>> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .collect(Collectors.toList());

, Nous pouvons éviter d'avoir des listes imbriquées en utilisant flatMap:

List<Integer> result = Stream.of(Arrays.asList(1), Arrays.asList(2, 3))
  .flatMap(i -> i.stream())
  .collect(Collectors.toList());

2

Optional<Optional<String>> result = Optional.of(42)
      .map(id -> findById(id));

Optional<String> result = Optional.of(42)
      .flatMap(id -> findById(id));

Où:

private Optional<String> findById(Integer id)

.carte est A -> B cartographie

Stream.of("dog", "cat")              // stream of 2 Strings
    .map(s -> s.length())            // stream of 2 Integers: [3, 3]

il convertit n'importe quel élément A pour tout élément de B. Javadoc

.flatMap est pour A -> Stream< B> concatinage

Stream.of("dog", "cat")             // stream of 2 Strings
    .flatMapToInt(s -> s.chars())   // stream of 6 ints:      [d, o, g, c, a, t]

il converts 1 convertit n'importe quel élément A en Stream< B>, puis --2 concatène tous les flux en un seul flux (plat). Javadoc

Note 1: Bien que ce dernier exemple apparaisse à un flux de primitives (IntStream) au lieu d'un flux d'objets (Stream), il illustre toujours l'idée du .flatMap.

Note 2: Malgré le nom, String.la méthode caractères () renvoie des ints. Donc, la collection réelle sera: [100, 111, 103, 99, 97, 116] où 100 est le code de 'd', 111 le code de 'o', etc. Encore une fois, à des fins d'illustration, il est présenté comme [d, o, g, c, a, t].

L'article d'Oracle sur Optional met en évidence cette différence entre map et flatmap:

String version = computer.map(Computer::getSoundcard)
                  .map(Soundcard::getUSB)
                  .map(USB::getVersion)
                  .orElse("UNKNOWN");

Malheureusement, ce code ne compile pas. Pourquoi? L'ordinateur variable est de type Optional<Computer>, il est donc parfaitement correct d'appeler le méthode map. Cependant, getSoundcard () renvoie un objet de type Facultatif. Cela signifie que le résultat de l'opération de carte est un objet de type Optional<Optional<Soundcard>>. En conséquence, l'appel à getUSB () n'est pas valide car l'option la plus externe contient comme son valeur une autre option, qui bien sûr ne prend pas en charge getUSB() méthode.

Avec streams, la méthode flatMap prend une fonction comme argument, qui renvoie un autre flux. Cette fonction est appliquée à chaque élément d'un flux, ce qui entraînerait un flux de flux. Cependant, flatMap a pour effet de remplacer chaque flux généré par le contenu de ce cours d'eau. En d'autres termes, tous les flux distincts qui sont générés par la fonction get amalgamated ou " aplati" dans un seul flux. Ce que nous voulons ici est quelque chose de similaire, mais nous voulons "aplatir" une option à deux niveaux en un.

Optionnel prend également en charge une méthode flatMap. Son but est d'appliquer la fonction de transformation sur la valeur d'un Optionnel (tout comme la carte l'opération fait), puis aplatir le facultatif à deux niveaux résultant en un seul.

Donc, pour corriger notre code, nous devons le réécrire comme suit en utilisant flatMap:

String version = computer.flatMap(Computer::getSoundcard)
                   .flatMap(Soundcard::getUSB)
                   .map(USB::getVersion)
                   .orElse("UNKNOWN");

Le premier flatMap garantit qu'un Optional<Soundcard> est retourné au lieu d'un Optional<Optional<Soundcard>>, et le deuxième flatMap atteint le même objectif pour retourner un Optional<USB>. Notez que l' le troisième appel doit juste être un map () car getVersion () renvoie un Chaîne plutôt que d'un objet Facultatif.

Http://www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

Map() et flatMap()

1. map()

Prend juste une Fonction un paramètre lambda où T est l'élément et R l'élément de retour construit en utilisant T. À la fin, nous aurons un flux avec des objets de type R. Un exemple simple peut être:

Stream
  .of(1,2,3,4,5)
  .map(myInt -> "preFix_"+myInt)
  .forEach(System.out::println);

Il prend simplement les éléments 1 à 5 de type Integer, utilise chaque élément pour construire un nouvel élément à partir du type String avec la valeur "prefix_"+integer_value et l'imprime.

1. flatMap()

, Il est utile de savoir que flatMap () prend une fonction F<T, R> où

• T est un type de à partir duquel un flux peut être construit/avec. Il peut s'agir d'une liste (T. stream()), d'un tableau (Arrays.flux(someArray)), etc.. tout ce à partir duquel un flux peut être avec/ou forme. dans l'exemple ci-dessous, chaque dev a de nombreuses langues, donc dev. Languages est une liste et utilisera un paramètre lambda.

• R est le flux résultant qui sera construit en utilisant T. Sachant que nous avons de nombreuses instances de T, nous aura naturellement de nombreux Flux de R. Tous ces flux de Type R seront maintenant combinés en un seul Flux "plat" unique de Type R.

Exemple

Exemples de Bachiri Taoufiq voir sa réponse ici sont simples et faciles à comprendre. Juste pour plus de clarté, disons simplement que nous avons une équipe de développeurs:

dev_team = {dev_1,dev_2,dev_3}

, chaque développeur connaissant plusieurs langages:

dev_1 = {lang_a,lang_b,lang_c},
dev_2 = {lang_d},
dev_2 = {lang_e,lang_f}

Application du flux .carte () sur dev_team pour obtenir les langues de chaque dev:

dev_team.map(dev -> dev.getLanguages())

Vous donnera cette structure:

{ 
  {lang_a,lang_b,lang_c},
  {lang_d},
  {lang_e,lang_f}
}

, Qui est fondamentalement un List<List<Languages>> /Object[Languages[]]. Pas si joli, ni Java8-like!!

Avec Stream.flatMap() vous pouvez "aplatir" les choses en prenant la structure ci-dessus
et le transforme en {lang_a, lang_b, lang_c, lang_d, lang_e, lang_f}, qui peut essentiellement être utilisé comme List<Languages>/Language[]/etc...

Donc à la fin, votre code aurait plus de sens comme ceci:

dev_team
   .stream()    /* {dev_1,dev_2,dev_3} */
   .map(dev -> dev.getLanguages()) /* {{lang_a,...,lang_c},{lang_d}{lang_e,lang_f}}} */
   .flatMap(languages ->  languages.stream()) /* {lang_a,...,lang_d, lang_e, lang_f} */
   .doWhateverWithYourNewStreamHere();

, Ou simplement:

dev_team
       .stream()    /* {dev_1,dev_2,dev_3} */
       .flatMap(dev -> dev.getLanguages().stream()) /* {lang_a,...,lang_d, lang_e, lang_f} */
       .doWhateverWithYourNewStreamHere();

Quand utiliser map () et utiliser flatMap():

• Utiliser map() lorsque chaque élément de type T à partir de votre flux est censé être mappé/transformé célibataire élément de type R. Le résultat est un mappage de type (1 élément de début -> 1 élément de fin) et le nouveau flux d'éléments de type R est retourné.

• Utiliser flatMap() lorsque chaque élément de type T à partir de votre flux est censé mappé/transformé Collections d'éléments de type R. Le résultat est une cartographie de type (1 élément de début -> n éléments de fin). Ces Collections sont alors fusionnées (ou aplaties ) en un nouveau flux d'éléments de type R. Ceci est utile par exemple pour représenter boucles imbriquées .

Pré Java 8:

List<Foo> myFoos = new ArrayList<Foo>();
    for(Foo foo: myFoos){
        for(Bar bar:  foo.getMyBars()){
            System.out.println(bar.getMyName());
        }
    }

Après Java 8

myFoos
    .stream()
    .flatMap(foo -> foo.getMyBars().stream())
    .forEach(bar -> System.out.println(bar.getMyName()));

Je ne suis pas très sûr d'être censé répondre à cela, mais chaque fois que je fais face à quelqu'un qui ne comprend pas cela, j'utilise le même exemple.

Imaginez que vous avez une pomme. Un map transforme cette pomme en apple-juice par exemple ou un mappageun à un .

Prenez cette même pomme et n'en extrayez que les graines, c'est ce que fait flatMap, ou un un à plusieurs , une pomme en entrée, de nombreuses graines en sortie.

Carte:- Cette méthode prend une fonction comme argument et renvoie un nouveau flux composé des résultats générés en appliquant la fonction passée à tous les éléments du flux.

Imaginons, j'ai une liste de valeurs entières ( 1,2,3,4,5 ) et une interface de fonction dont la logique est carrée de l'entier passé. ( e -> e * e ).

List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> newList = intList.stream().map( e -> e * e ).collect(Collectors.toList());

System.out.println(newList);

Sortie:-

[1, 4, 9, 16, 25]

Comme vous pouvez le voir, une sortie est un nouveau flux dont les valeurs sont carrées des valeurs de l'entrée flux.

[1, 2, 3, 4, 5] -> apply e -> e * e -> [ 1*1, 2*2, 3*3, 4*4, 5*5 ] -> [1, 4, 9, 16, 25 ]

Http://codedestine.com/java-8-stream-map-method/

FlatMap :- Cette méthode prend une fonction comme argument, cette fonction accepte un paramètre T comme argument d'entrée et renvoie un flux de paramètre R comme valeur de retour. Lorsque cette fonction est appliquée à chaque élément de ce courant, il produit un flux de nouvelles valeurs. Tous les éléments de ces nouveaux flux générés par chaque élément sont ensuite copiés dans un nouveau flux, qui sera une valeur de retour de cette méthode.

Image Let, j'ai une liste d'objets étudiants, où chaque étudiant peut opter pour plusieurs matières.

List<Student> studentList = new ArrayList<Student>();

  studentList.add(new Student("Robert","5st grade", Arrays.asList(new String[]{"history","math","geography"})));
  studentList.add(new Student("Martin","8st grade", Arrays.asList(new String[]{"economics","biology"})));
  studentList.add(new Student("Robert","9st grade", Arrays.asList(new String[]{"science","math"})));

  Set<Student> courses = studentList.stream().flatMap( e -> e.getCourse().stream()).collect(Collectors.toSet());

  System.out.println(courses);

Sortie:-

[economics, biology, geography, science, history, math]

Comme vous pouvez le voir, une sortie est un nouveau flux dont les valeurs sont une collection de tous les éléments des flux renvoyés par chaque élément du flux d'entrée.

[S1 , S2 , S3] - > [ {"histoire","mathématiques","géographie"}, {"economie","biologie"}, {"science","mathématiques"} ] -> prendre unique sujets -> [économie, biologie, géographie, sciences, histoire, mathématiques]

Http://codedestine.com/java-8-stream-flatmap-method/

Si vous pensez map() comme une itération(une boucle for de niveau), flatmap() est une itération à deux niveaux(comme une boucle for imbriquée). (Entrez chaque élément itéré foo, et faites foo.getBarList() et itérez à nouveau dans ce barList)

map(): prenez un flux, faites quelque chose pour chaque élément, collectez le résultat unique de chaque processus, produisez un autre flux. La définition de "fonction faire quelque chose" est implicite. Si le traitement d'un élément entraîne null, null est utilisé pour composer le flux final. Ainsi, le nombre d'éléments dans le flux résultant sera égal au nombre de flux d'entrée.

flatmap(): prenez un flux de éléments/flux et une fonction(définition explicite), appliquez la fonction à chaque élément de chaque flux et collectez tout le flux résultant intermédiaire pour qu'il soit un flux plus grand("aplatissement"). Si le traitement d'un élément donne null, un flux vide est fourni à l'étape finale de "l'aplatissement". Le nombre d'éléments dans le flux résultant est le total de tous les éléments participants dans toutes les entrées, si l'entrée est plusieurs flux.

Réponse simple.

Le map opération peut produire un Stream de Stream.EX Stream<Stream<Integer>>

flatMap l'opération ne produira que Stream de quelque chose. EX Stream<Integer>

Aussi une bonne analogie peut être avec C# si vous connaissez. Fondamentalement, C# Select similaire à java map et C# SelectMany java flatMap. Il en va de même pour Kotlin pour les collections.

Ceci est très déroutant pour les débutants. La différence de base est map émet un élément pour chaque entrée dans la liste et flatMap est fondamentalement un map + flatten le fonctionnement. Pour être plus clair, utilisez flatMap lorsque vous avez besoin de plus d'une valeur, par exemple lorsque vous vous attendez à ce qu'une boucle renvoie des tableaux, flatMap sera vraiment utile dans ce cas.

J'ai écrit un blog à ce sujet, vous pouvez le vérifier ici.

Les opérations de flux flatMap et map acceptent une fonction en entrée.

flatMap s'attend à ce que la fonction renvoie un nouveau flux pour chaque élément du flux et renvoie un flux qui combine tous les éléments des flux renvoyés par la fonction pour chaque élément. En d'autres termes, avec flatMap, pour chaque élément de la source, plusieurs éléments seront créés par la fonction. http://www.zoftino.com/java-stream-examples#flatmap-operation

map attend la fonction pour renvoyer une valeur transformée et renvoie un nouveau flux contenant les éléments transformés. En d'autres termes, avec map, pour chaque élément de la source, un élément transformé sera créé par la fonction. http://www.zoftino.com/java-stream-examples#map-operation

flatMap() profite également de l'évaluation paresseuse partielle des flux. Il lira le flux de poing et seulement si nécessaire, ira au flux suivant. Le comportement est expliqué en détail ici: flatMap est-il garanti paresseux?