Quelle est la différence entre la carte et flatMap méthodes en Java 8?

Stream.flatMap, comme on peut le deviner par son nom, est la combinaison d'un map et un flat opération. Cela signifie que vous devez d'abord appliquer une fonction à vos éléments, et puis l'aplatir. Stream.map ne s'applique qu'une fonction pour les flux sans l'aplatissement de la rivière.

De comprendre ce aplatissement un flux consiste en, envisager une structure comme [ [1,2,3],[4,5,6],[7,8,9] ] qui a "deux niveaux". L'aplatissement cela signifie en le transformant en un "niveau" de la structure : [ 1,2,3,4,5,6,7,8,9 ].

S'il vous plaît aller à travers le poste entièrement pour se faire une idée claire,

carte vs flatMap:

Pour revenir à une longueur de chaque mot dans une liste, nous ferions quelque chose comme ci-dessous..

Version courte étant donné ci-dessous

Lorsque nous recueillons des deux listes, donnée ci-dessous

Sans plat de 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 des listes

Avec plat de la carte => [1,2],[1,1] => [1,2,1,1] Ici deux listes sont aplaties et seules les valeurs sont placées dans la liste, de sorte que la sortie sera liste ne contenant que des éléments

Fondamentalement, il fusionne tous les objets dans one

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

Par exemple:-
tenir compte d'une liste [“PILE”, ”OOOVVVER”] et nous essayons de revenir une liste comme [“STACKOVER”](retour uniquement unique des lettres à partir de cette liste)
D'abord, nous voudrions faire quelque chose comme ci-dessous pour retourner une liste [“STACKOVER”] de [“PILE”, ”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 la question est, Lambda passé la carte de la méthode retourne un tableau de chaînes, pour chaque mot, de Sorte que le flux retourné par la méthode map est en fait de type de Flux, Mais nous avons besoin de Flux de 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 carte 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 prend un tableau et produit un flux de données, 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());

Le ci-dessus ne fonctionne toujours pas, car nous avons maintenant jusqu'à la fin avec une liste de cours d'eau (plus précisément, Flux>), au Lieu de cela, nous devons d'abord convertir chaque mot dans un tableau de lettres, puis faire de chaque tableau dans 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 effectuer la cartographie de chaque tableau pas de stream, mais avec le contenu de ce cours d'eau. Tous les flux individuels qui serait généré lors de l'utilisation de la carte(les Tableaux::stream) sont fusionnés en un seul flux. La Figure B montre l'effet de l'utilisation de la flatMap méthode. Comparer avec ce que la carte ne figure A.
Figure B

La flatMap méthode permet de remplacer chaque valeur d'un ruisseau avec un autre flux, puis rejoint l'ensemble de l'généré des flux en un seul flux.

La fonction que vous passez à stream.map doit retourner un objet. Cela signifie que chaque objet dans le flux d'entrée des résultats dans 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). La conséquence, les flux sont ensuite concaténées à un flux de sortie.

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

Il y a des cas où on peut se retrouver avec des structures imbriquées lors de l'utilisation de map(), le flatMap() méthode est destinée à résoudre ce problème en évitant d'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)

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

Imaginez que vous avez un apple. Un map est que la transformation de la pomme de apple-juice, par exemple, ou un un-à-un de cartographie.

Prendre que même apple et d'obtenir seulement les graines en dehors de ça, c'est ce que flatMap n', ou un un à plusieurs, une pomme comme entrée, beaucoup de graines en sortie.

map() et flatMap()

1. map()

Prend juste une Fonction lambda param où T est l'élément et R le retour de l'élément construit à l'aide de T. À la fin, nous aurons un Ruisseau 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 suffit d'éléments de 1 à 5 de Type Integer, utilise chaque élément de construire un nouvel élément de type String avec la valeur "prefix_"+integer_value et l'imprime sur.

1. flatMap()

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

• T est un type de laquelle un cours d'eau peut être construit à partir de/avec. Il peut être une Liste (T. stream()), un tableau (Tableaux.flux(someArray)), etc.. tout ce qui à partir de laquelle un Flux peut être avec/ou de la forme. dans l'exemple ci-dessous chaque dev a beaucoup de langues, afin de dev. Langues est une Liste, et d'utiliser un paramètre lambda.

• R est le Flux qui va être construit à l'aide de T. Sachant que nous avons de nombreux cas de T, on aura naturellement de nombreux cours d'eau de R. l'Ensemble de ces Flux de Type R ne maintenant être combinés en un seul unique "à plat" un Flux de Type R.

Exemple

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

dev_team = {dev_1,dev_2,dev_3}

avec à chaque développeur de connaître plusieurs langues:

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

L'Application De Flux.map() 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 essentiellement un List<List<Languages>> /Object[Languages[]]. Pas très joli, ni Java8 comme!!

avec Stream.flatMap() vous pouvez "aplatir" les choses comme il faut de la structure ci-dessus

et il se transforme en {lang_a, lang_b, lang_c, lang_d, lang_e, lang_f}, qui peut être simplement utilisé comme List<Languages>/Language[]/ect...

de sorte que la fin de votre code aurait plus de sens comme ça:

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 tout simplement:

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

Lors de l'utilisation de la carte() et utiliser flatMap():

• Utilisation map() lorsque chaque élément de type T à partir de votre flux est censé être mappé/transformées à un unique é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 de nouveaux flux d'éléments de type R est retourné.

• Utilisation flatMap() lorsque chaque élément de type T à partir de votre flux est censé mappé/transformées à un Collections d'éléments de type R. Le résultat est un mappage de type (1 élément de début -> n la fin des éléments). Ces Collections sont ensuite fusionné (ou aplatie) à un nouveau flux d'éléments de type R. C'est utile par exemple pour représenter boucles imbriquées.

Avant Java 8:

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

Post Java 8

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

C'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 opération. Pour être plus clair, l'utilisation flatMap lorsque vous avez besoin de plus d'une valeur, par exemple, lorsque vous vous attendez à une boucle de retour des tableaux, flatMap sera vraiment utile dans ce cas.

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

Flux des opérations de flatMap et map accepter une fonction d'entrée.

flatMap s'attend à ce que la fonction de retour d'un nouveau flux de données pour chaque élément du flux et renvoie un flux de données qui combine tous les éléments du flux renvoyé par la fonction de 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 s'attend à ce que la fonction de retour de la transformation de la valeur et renvoie un nouveau flux contenant de la transformation des éléments. En d'autres termes, avec map, pour chaque élément de la source, on a transformé élément sera créé par la fonction.
http://www.zoftino.com/java-stream-examples#map-operation

map() en Java 8

un flux de données comprenant les résultats de l'application de la fonction donnée aux éléments de ce flux. La carte prend une entrée qui décrit la façon dont la valeur doit être transformée en.
Supposons que nous voulons obtenir de l'âge de l'Étudiant dont le nom est Saurabh, jusqu'à maintenant, nous avons seulement récupéré l'objet, à partir du flux mais comment faisons-nous cela ?
Nous pouvons utiliser la carte() pour transformer l'Étudiant Ruisseau jusqu'à l'âge de flux ci-dessous.

int age = students.stream()
.filter(student -> SAURABH.equals(student.getName()))
.map(Student::getAge)
.findAny()
.orElse(0);
System.out.printf("*** Age of %s is %d\n",SAURABH, age);

Permet maintenant essayer d'obtenir tous les noms des élèves avec l'aide de collect()

Set<String> names = students.stream()
.map(Student::getName) //this will convert the Student Stream into String Stream by 
//applying the getName()
.collect(Collectors.toSet());  
System.out.printf("*** All the names from the list is %s\n",names);

map() vs flatMap()

Supposons que nous voulons récupérer tous les cours disponibles dans les étudiants de la liste alors nous pouvons écrire le code comme ci-dessous:

Set<String> courses = students.stream()
.map(Student::getCourses)
.collect(Collectors.toSet())

**Ici, nous allons obtenir une erreur de compilation comme ci-dessous

Incompatibilité de Type: impossible de convertir de Définir à Définir
Pour résoudre ce problème, nous utilisons flatMap()**

flatMap() en Java 8

Il renvoie un flux de données comprenant les résultats de remplacer chaque élément de ce flux avec le contenu d'un mappage de flux produit par l'application de la condition de la cartographie de la fonction de chaque élément.
flatMap va transformer le flux de flux de données en simple flux. Dans l'exemple ci-dessous, nous utilisons la flatMap pour convertir le Tableau de Flux dans la Chaîne de stream.

Set<String> courses = students.stream()
.map(Student::getCourses)
.flatMap(Arrays::stream)
.collect(Collectors.toSet());

Pour plus d'informations vous pouvez vous référer aux liens ci-dessous :

https://onlyfullstack.blogspot.com/2018/12/map-vs-flatmap-in-java-8.html

http://onlyfullstack.blogspot.com/p/java-8-features.html