What s the difference between map and flatMap methods in Java 8

Question

In Java 8  what s the difference between Stream map   and Stream flatMap   methods

User · Answer

If you think map   as an iteration one level for loop   flatmap   is a two-level iteration like a nested for loop    Enter each iterated element foo  and do foo getBarList   and iterate in that barList again     map    take a stream  do something to every element  collect the single result of every process  output another stream  The definition of  do something function  is implicit  If the processment of any element results in null  null is used to compose the final stream  So  the number of elements in the resulting stream will be equal to number of input stream   flatmap    take a stream of elements streams and a function explicit definition   apply the function to each element of each stream  and collect all the intermediate resulting stream to be a greater stream  flattening    If the processment of any element results in null  empty stream is provided to the final step of  flattening   The number of elements in the resulting stream  is the total of all participating elements in all inputs  if the input is several streams

User · Answer

This is very confusing for beginners  The basic difference is map emits one item for each entry in the list and flatMap is basically a map   flatten operation  To be more clear  use flatMap when you require more than one value  eg when you are expecting a loop to return arrays  flatMap will be really helpful in this case   I have written a blog about this  you can check it out here

User · Answer

map is for A - gt  B mapping Stream of  quot dog quot    quot cat quot                   stream of 2 Strings      map s - gt  s length                  stream of 2 Integers   3  3   it converts any item A to any item B  Javadoc   flatMap is for A - gt  Stream lt  B gt  concatinating Stream of  quot dog quot    quot cat quot                  stream of 2 Strings      flatMapToInt s - gt  s chars         stream of 6 ints        d  o  g  c  a  t   it --1 converts any item A into Stream lt  B gt   then --2 concatenates all the streams into one  flat  stream  Javadoc  Note 1  Although the latter example flats to a stream of primitives  IntStream  instead of a stream of objects  Stream   it still illustrates the idea of the  flatMap  Note 2  Despite the name  String chars   method returns ints  So the actual collection will be   100  111  103  99  97  116    where 100 is the code of  d   111 is the code of  o  etc  Again  for illustrative purposes  it s presented as  d  o  g  c  a  t

User · Answer

map   and flatMap      map     Just takes a Function  a lambda param where T is element and R the return element built using T  At the end we ll have a Stream with objects of Type R  A simple example can be   Stream    of 1 2 3 4 5     map myInt - gt   preFix   myInt     forEach System out  println     It simply takes elements 1 to 5 of Type Integer  uses each element to build a new element from type String with value  prefix   integer value and prints it out    flatMap     It is useful to know that flatMap   takes a function F lt T  R gt  where   T is a type from which a Stream can be built from with  It can be a List  T stream     an array  Arrays stream someArray    etc   anything that from which a Stream can be with or form  in the example below each dev has many languages  so dev  Languages is a List and will use a lambda parameter   R is the resulting Stream that will be built using T  Knowing that we have many instances of T  we will naturally have many Streams from R  All these Streams from Type R will now be combined into one single  flat  Stream from Type R      Example  The examples of Bachiri Taoufiq  see its answer here are simple and easy to understanding  Just for clarity  let just say we have a team of developers   dev team    dev 1 dev 2 dev 3      with each developer knowing  many languages   dev 1    lang a lang b lang c   dev 2    lang d   dev 2    lang e lang f    Applying  Stream map   on dev team to get the languages of each dev   dev team map dev - gt  dev getLanguages      will give you this structure         lang a lang b lang c      lang d      lang e lang f      which is basically a List lt List lt Languages gt  gt   Object Languages     Not so very pretty  nor Java8-like    with Stream flatMap   you can  flatten  things out as it takes the above structure and turns it into  lang a  lang b  lang c  lang d  lang e  lang f   which can basically used as List lt Languages gt  Language   etc     so in the end  your code would make more sense like this   dev team     stream          dev 1 dev 2 dev 3         map dev - gt  dev getLanguages         lang a     lang c   lang d  lang e lang f           flatMap languages - gt   languages stream        lang a     lang d  lang e  lang f         doWhateverWithYourNewStreamHere      or simply   dev team         stream          dev 1 dev 2 dev 3             flatMap dev - gt  dev getLanguages   stream        lang a     lang d  lang e  lang f             doWhateverWithYourNewStreamHere      When to use map   and use flatMap      Use map   when each element of type T from your stream is supposed to be mapped transformed to a single element of type R  The result is a mapping of type  1 start element -  1 end element  and new stream of elements of type R is returned  Use flatMap   when each element of type T from your stream is supposed to mapped transformed to a Collections of elements of type R  The result is a mapping of type  1 start element -  n end elements   These Collections are then merged  or flattened  to a new stream of elements of type R  This is useful for example to represent nested loops    Pre Java 8    List lt Foo gt  myFoos   new ArrayList lt Foo gt         for Foo foo  myFoos           for Bar bar   foo getMyBars                 System out println bar getMyName                       Post Java 8  myFoos      stream        flatMap foo - gt  foo getMyBars   stream         forEach bar - gt  System out println bar getMyName

User · Answer

Also good analogy can be with C  if you familiar with  Basically C  Select similar to java map and C  SelectMany java flatMap  Same applies to Kotlin for collections

User · Answer

Stream flatMap  as it can be guessed by its name  is the combination of a map and a flat operation  That means that you first apply a function to your elements  and then flatten it  Stream map only applies a function to the stream without flattening the stream   To understand what flattening a stream consists in  consider a structure like    1 2 3   4 5 6   7 8 9    which has  two levels   Flattening this means transforming it in a  one level  structure     1 2 3 4 5 6 7 8 9

User · Answer

I am not very sure I am supposed to answer this  but every time I face someone that does not understand this  I use the same example    Imagine you have an apple  A map is transforming that apple to apple-juice for example or a one-to-one mapping    Take that same apple and get only the seeds out of it  that is what flatMap does  or a one to many  one apple as input  many seeds as output

User · Answer

Simple answer   The map operation can produce a Stream of Stream EX Stream lt Stream lt Integer gt  gt   flatMap operation will only produce Stream of something  EX Stream lt Integer gt

User · Answer

I have a feeling that most answers here overcomplicate the simple problem  If you already understand how the map works that should be fairly easy to grasp   There are cases where we can end up with unwanted nested structures when using map    the flatMap   method is designed to overcome this by avoiding wrapping     Examples   1  List lt List lt Integer gt  gt  result   Stream of Arrays asList 1   Arrays asList 2  3      collect Collectors toList       We can avoid having nested lists by using flatMap   List lt Integer gt  result   Stream of Arrays asList 1   Arrays asList 2  3      flatMap i - gt  i stream       collect Collectors toList       2  Optional lt Optional lt String gt  gt  result   Optional of 42         map id - gt  findById id     Optional lt String gt  result   Optional of 42         flatMap id - gt  findById id      where   private Optional lt String gt  findById Integer id

User · Answer

I would like to give 2 examples to get a more practical point of view  First example making usage of map   Test public void convertStringToUpperCaseStreams         List lt String gt  collected   Stream of  quot a quot    quot b quot    quot hello quot      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  quot A quot    quot B quot    quot HELLO quot    collected      Nothing special in the first example  a Function is applied to return the String in uppercase  Second example making usage of flatMap   Test public void testflatMap   throws Exception       List lt Integer gt  together   Stream of asList 1  2   asList 3  4      Stream of List lt Integer gt               flatMap List  stream               map integer - gt  integer   1               collect Collectors toList         assertEquals asList 2  3  4  5   together      In the second example  a Stream of List is passed  It is NOT a Stream of Integer  If a transformation Function has to be used  through map   then first the Stream has to be flattened to something else  a Stream of Integer   If flatMap is removed then the following error is returned  The operator   is undefined for the argument type s  List  int  It is NOT possible to apply   1 on a List of Integers

User · Answer

Oracle s article on Optional highlights this difference between map and flatmap    String version   computer map Computer  getSoundcard                     map Soundcard  getUSB                     map USB  getVersion                     orElse  UNKNOWN         Unfortunately  this code doesn t compile  Why  The variable computer   is of type Optional lt Computer gt   so it is perfectly correct to call the   map method  However  getSoundcard   returns an object of type   Optional  This means the result of the map operation is an   object of type Optional lt Optional lt Soundcard gt  gt   As a result  the call to   getUSB   is invalid because the outermost Optional contains as its   value another Optional  which of course doesn t support the getUSB     method       With streams  the flatMap method takes a function as an argument    which returns another stream  This function is applied to each element   of a stream  which would result in a stream of streams  However    flatMap has the effect of replacing each generated stream by the   contents of that stream  In other words  all the separate streams that   are generated by the function get amalgamated or  flattened  into one   single stream  What we want here is something similar  but we want to    flatten  a two-level Optional into one       Optional also supports a flatMap method  Its purpose is to apply   the transformation function on the value of an Optional  just like the map   operation does  and then flatten the resulting two-level Optional into   a single one       So  to make our code correct  we need to rewrite it as follows using   flatMap    String version   computer flatMap Computer  getSoundcard                      flatMap Soundcard  getUSB                      map USB  getVersion                      orElse  UNKNOWN         The first flatMap ensures that an Optional lt Soundcard gt  is returned   instead of an Optional lt Optional lt Soundcard gt  gt   and the second flatMap   achieves the same purpose to return an Optional lt USB gt   Note that the   third call just needs to be a map   because getVersion   returns a   String rather than an Optional object    http   www oracle com technetwork articles java java8-optional-2175753 html

User · Answer

for a Map we have a list of elements and a  function action  f so     a b c  f x    gt   f a  f b  f c     and for the flat map we have a list of elements list and we have a  function action  f and we want the result to be flattened      a b   c d e   f x    gt  f a  f b  f c  f d  f e

User · Answer

The function you pass to stream map has to return one object  That means each object in the input stream results in exactly one object in the output stream   The function you pass to stream flatMap returns a stream for each object  That means the function can return any number of objects for each input object  including none   The resulting streams are then concatenated to one output stream

User · Answer

One line answer  flatMap helps to flatten a Collection lt Collection lt T gt  gt  into a Collection lt T gt   In the same way  it will also flatten an Optional lt Optional lt T gt  gt  into Optional lt T gt      As you can see  with map   only    The intermediate type is Stream lt List lt Item gt  gt  The return type is List lt List lt Item gt  gt    and with flatMap      The intermediate type is Stream lt Item gt  The return type is List lt Item gt    This is the test result from the code used right below    -------- Without flatMap   -------------------------------      collect   returns    Laptop  Phone    Mouse  Keyboard    -------- With flatMap   ----------------------------------      collect   returns   Laptop  Phone  Mouse  Keyboard    Code used   import java util Arrays  import java util Collection  import java util List  import java util stream Collectors   public class Parcel     String name    List lt String gt  items     public Parcel String name  String    items        this name   name      this items   Arrays asList items          public List lt String gt  getItems         return items         public static void main String   args        Parcel amazon   new Parcel  amazon    Laptop    Phone        Parcel ebay   new Parcel  ebay    Mouse    Keyboard        List lt Parcel gt  parcels   Arrays asList amazon  ebay        System out println  -------- Without flatMap   ---------------------------        List lt List lt String gt  gt  mapReturn   parcels stream          map Parcel  getItems         collect Collectors toList         System out println   t collect   returns      mapReturn        System out println   n-------- With flatMap   ------------------------------        List lt String gt  flatMapReturn   parcels stream          map Parcel  getItems         flatMap Collection  stream         collect Collectors toList         System out println   t collect   returns      flatMapReturn

User · Answer

Both map and flatMap can be applied to a Stream lt T gt  and they both return a Stream lt R gt   The difference is that the map operation produces one output value for each input value  whereas the flatMap operation produces an arbitrary number  zero or more  values for each input value   This is reflected in the arguments to each operation   The map operation takes a Function  which is called for each value in the input stream and produces one result value  which is sent to the output stream   The flatMap operation takes a function that conceptually wants to consume one value and produce an arbitrary number of values  However  in Java  it s cumbersome for a method to return an arbitrary number of values  since methods can return only zero or one value  One could imagine an API where the mapper function for flatMap takes a value and returns an array or a List of values  which are then sent to the output  Given that this is the streams library  a particularly apt way to represent an arbitrary number of return values is for the mapper function itself to return a stream  The values from the stream returned by the mapper are drained from the stream and are passed to the output stream  The  clumps  of values returned by each call to the mapper function are not distinguished at all in the output stream  thus the output is said to have been  flattened    Typical use is for the mapper function of flatMap to return Stream empty   if it wants to send zero values  or something like Stream of a  b  c  if it wants to return several values  But of course any stream can be returned

User · Answer

Stream operations flatMap and map accept a function as input    flatMap expects the function to return a new stream for each element of the stream and returns a stream which combines all the elements of the streams returned by the function for each element  In other words  with flatMap  for each element from the source  multiple elements will be created by the function  http   www zoftino com java-stream-examples flatmap-operation  map expects the function to return a transformed value and returns a new stream containing the transformed elements  In other words  with map  for each element from the source  one transformed element will be created by the function  http   www zoftino com java-stream-examples map-operation

User · Answer

Please go through the post fully to get a clear idea   map vs flatMap   To return a length  of each word from a list  we would do something like below    Short Version given below  When we collect two lists  given below   Without flat map     1 2   1 1       1 2   1 1   Here two lists are placed inside a list  so the output will be list containing lists  With flat map     1 2   1 1      1 2 1 1  Here two lists are flattened and only the values are placed in list  so the output will be list containing only elements   Basically it merges all the objects in to one     Detailed Version has been given below -  For example - Consider a list     STACK        OOOVVVER     and we are trying to return a list like     STACKOVER     returning only unique letters from that list  Initially  we would do something like below to return a list      STACKOVER      from      STACK        OOOVVVER      public class WordMap     public static void main String   args        List lt String gt  lst   Arrays asList  STACK   OOOVER        lst stream   map w- gt w split      distinct   collect Collectors toList             Here the issue is  Lambda passed to the map method returns a String array for each word  So the stream returned by the map method is actually of type Stream  But what we need is Stream to represent a stream of characters  below image illustrates the problem   Figure A     You might think that  We can resolve this problem using flatmap  OK  let us see how to solve this by using map and Arrays stream First of all you gonna need a stream of characters instead of a stream of arrays  There is a method called Arrays stream   that would take an array and produces a stream  for example   String   arrayOfWords     STACK    OOOVVVER    Stream lt String gt  streamOfWords   Arrays stream arrayOfWords   streamOfWords map s- gt s split        Converting word in to array of letters      map Arrays  stream  distinct     Make array in to separate stream      collect Collectors toList       The above still does not work  because we now end up with a list of streams  more precisely  Stream    Instead  we must first convert each word into an array of individual letters and then make each array into a separate stream  By using flatMap we should be able to fix this problem as below   String   arrayOfWords     STACK    OOOVVVER    Stream lt String gt  streamOfWords   Arrays stream arrayOfWords   streamOfWords map s- gt 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 would perform mapping each array not with stream but with the contents of that stream  All of the individual streams that would get generated while using map Arrays  stream  get merged into a single stream  Figure B illustrates the effect of using the flatMap method  Compare it with what map does in figure A  Figure B   The flatMap method lets you replace each value of a stream with another stream and then joins all the generated streams into a single stream

User · Answer

Map -  This method takes one Function as an argument and returns a new stream consisting of the results generated by applying the passed function to all the elements of the stream   Let s imagine  I have a list of integer values   1 2 3 4 5   and one function interface whose logic is square of the passed integer    e -  e   e      List lt Integer gt  intList   Arrays asList 1  2  3  4  5    List lt Integer gt  newList   intList stream   map  e - gt  e   e   collect Collectors toList      System out println newList     output -    1  4  9  16  25    As you can see  an output is a new stream whose values are square of values of the input stream    1  2  3  4  5  - gt  apply e - gt  e   e - gt    1 1  2 2  3 3  4 4  5 5   - gt   1  4  9  16  25     http   codedestine com java-8-stream-map-method   FlatMap  -  This method takes one Function as an argument  this function accepts one parameter T as an input argument and returns one stream of parameter R as a return value  When this function is applied to each element of this stream  it produces a stream of new values  All the elements of these new streams generated by each element are then copied to a new stream  which will be a return value of this method    Let s image  I have a list of student objects  where each student can opt for multiple subjects   List lt Student gt  studentList   new ArrayList lt Student gt        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 lt Student gt  courses   studentList stream   flatMap  e - gt  e getCourse   stream    collect Collectors toSet        System out println courses     output -    economics  biology  geography  science  history  math    As you can see  an output is a new stream whose values are a collection of all the elements of the streams return by each element of the input stream     S1   S2   S3    -      history   math   geography      economics   biology      science   math     -  take unique subjects -   economics  biology  geography  science  history  math   http   codedestine com java-8-stream-flatmap-method

User · Answer

flatMap   also takes advantage of partial lazy evaluation of streams  It will read the fist stream and only when required  will go to the next stream  The behaviour is explained in detail here  Is flatMap guaranteed to be lazy

[java] What's the difference between map() and flatMap() methods in Java 8?

Examples related to java

Examples related to java-8

Examples related to java-stream