what is the actual difference between map() and flatMap()?

bambizas19 · 2024-01-26T12:22:06.268Z

hi guys. can smb help me out with `stream().map()` and `stream().flatmap`? In the google i saw that `flatmap` flattens smth. What does it even mean? Can smb explain? Thanks alot

J

JavaBot•1/26/24, 12:22 PM

J

JavaBot•1/26/24, 12:22 PM

⌛

⌛

This post has been reserved for your question.

Hey @bambyzas! Please use
/close
/close
or the
Close Post
Close Post
button above when your problem is solved. Please remember to follow the help guidelines. This post will be automatically closed after 300 minutes of inactivity.

TIP: Narrow down your issue to simple and precise questions to maximize the chance that others will reply in here.

K

Kyo-chan•1/26/24, 12:30 PM

To map() and flatMap(), you pass converters. Converting each item of the stream to something else, making the original stream a new stream where all is converted.

But with flatMap(), the converter has to convert to a stream of something. If you gave the same converter to just map(), that would result in a stream of streams of stuff, which isn't useful.

flatMap() applies the converter given, but flattens the result. Instead of giving out a stream of streams of stuff, it gives out just a stream of stuff.

0

0x150•1/26/24, 12:31 PM

-> with flatMap, one element becomes many

0

0x150•1/26/24, 12:32 PM

eg if you have a stream of “ab”, “cd” flatMapping it with a function that turns the string into their individual characters and returns a stream of them returns in the stream “a”, “b”, “c”, “d”

00x150 -> with flatMap, one element becomes many

T

tjoener•1/26/24, 12:34 PM

Yes, but to be more precise, 0 and 1 are also perfectly fine

B

bambizas19OP•1/26/24, 12:43 PM

can u guys give me an example?

B

bambizas19OP•1/26/24, 12:43 PM

if i have List<Vegetables> and i do flatmap on it. what would i get?

T

tjoener•1/26/24, 12:44 PM

Well does a vegetable itself contain a list of some kind?

B

bambizas19OP•1/26/24, 12:46 PM

no. Vegetable is just a pojo

T

tjoener•1/26/24, 12:47 PM

yeah, flatmap isn't really useful then

T

tjoener•1/26/24, 12:47 PM

Lets say you have a list of users, and each user has a list of emails, then you can use flatmap

T

tjoener•1/26/24, 12:48 PM

eg:

users.stream().flatMap(user -> user.getEmails().stream()).collect(Collectors.toList())

users.stream().flatMap(user -> user.getEmails().stream()).collect(Collectors.toList())

users.stream().flatMap(user -> user.getEmails().stream()).collect(Collectors.toList())

users.stream().flatMap(user -> user.getEmails().stream()).collect(Collectors.toList())

T

tjoener•1/26/24, 12:48 PM

This will give you a list of all users' emails

Ttjoener yeah, flatmap isn't really useful then

B

bambizas19OP•1/26/24, 12:52 PM

ok i did some improvements. lets say i ahve such case:

Vegetable apple1 = new Vegetable(1, "apple1", 1);
        Vegetable pear1 = new Vegetable(11, "pear1", 11);
        Vegetable egg1 = new Vegetable(111, "egg1", 111);

        Farmer farmer1 = new Farmer();
        farmer1.setFirstName("Name1");
        farmer1.setId(1);
        farmer1.setLicense("license1");
        farmer1.setLastName("LastName1");
        farmer1.setVegetables(List.of(apple1,pear1,egg1);

        Vegetable apple2 = new Vegetable(2, "apple2", 2);
        Vegetable pear2 = new Vegetable(22, "pear2", 22);
        Vegetable egg2 = new Vegetable(222, "egg2", 222);

        Farmer farmer2 = new Farmer();
        farmer2.setFirstName("Name2");
        farmer2.setId(2);
        farmer2.setLicense("license2");
        farmer2.setLastName("LastName2");
        farmer2.setVegetables(List.of(apple2, pear2, egg2));

        List<Farmer> farmerList = new ArrayList<>();
        farmerList.add(farmer1);
        farmerList.add(farmer2);

        //List<String> farmerNames = farmerList.stream().map(farmer -> farmer.getFirstName()).collect(Collectors.toList());

        farmerList.stream().flatMap(farmer -> farmer.getVegetables(

Vegetable apple1 = new Vegetable(1, "apple1", 1);
        Vegetable pear1 = new Vegetable(11, "pear1", 11);
        Vegetable egg1 = new Vegetable(111, "egg1", 111);

        Farmer farmer1 = new Farmer();
        farmer1.setFirstName("Name1");
        farmer1.setId(1);
        farmer1.setLicense("license1");
        farmer1.setLastName("LastName1");
        farmer1.setVegetables(List.of(apple1,pear1,egg1);

        Vegetable apple2 = new Vegetable(2, "apple2", 2);
        Vegetable pear2 = new Vegetable(22, "pear2", 22);
        Vegetable egg2 = new Vegetable(222, "egg2", 222);

        Farmer farmer2 = new Farmer();
        farmer2.setFirstName("Name2");
        farmer2.setId(2);
        farmer2.setLicense("license2");
        farmer2.setLastName("LastName2");
        farmer2.setVegetables(List.of(apple2, pear2, egg2));

        List<Farmer> farmerList = new ArrayList<>();
        farmerList.add(farmer1);
        farmerList.add(farmer2);

        //List<String> farmerNames = farmerList.stream().map(farmer -> farmer.getFirstName()).collect(Collectors.toList());

        farmerList.stream().flatMap(farmer -> farmer.getVegetables(

Vegetable apple1 = new Vegetable(1, "apple1", 1);
        Vegetable pear1 = new Vegetable(11, "pear1", 11);
        Vegetable egg1 = new Vegetable(111, "egg1", 111);

        Farmer farmer1 = new Farmer();
        farmer1.setFirstName("Name1");
        farmer1.setId(1);
        farmer1.setLicense("license1");
        farmer1.setLastName("LastName1");
        farmer1.setVegetables(List.of(apple1,pear1,egg1);

        Vegetable apple2 = new Vegetable(2, "apple2", 2);
        Vegetable pear2 = new Vegetable(22, "pear2", 22);
        Vegetable egg2 = new Vegetable(222, "egg2", 222);

        Farmer farmer2 = new Farmer();
        farmer2.setFirstName("Name2");
        farmer2.setId(2);
        farmer2.setLicense("license2");
        farmer2.setLastName("LastName2");
        farmer2.setVegetables(List.of(apple2, pear2, egg2));

        List<Farmer> farmerList = new ArrayList<>();
        farmerList.add(farmer1);
        farmerList.add(farmer2);

        //List<String> farmerNames = farmerList.stream().map(farmer -> farmer.getFirstName()).collect(Collectors.toList());

        farmerList.stream().flatMap(farmer -> farmer.getVegetables(

Vegetable apple1 = new Vegetable(1, "apple1", 1);
        Vegetable pear1 = new Vegetable(11, "pear1", 11);
        Vegetable egg1 = new Vegetable(111, "egg1", 111);

        Farmer farmer1 = new Farmer();
        farmer1.setFirstName("Name1");
        farmer1.setId(1);
        farmer1.setLicense("license1");
        farmer1.setLastName("LastName1");
        farmer1.setVegetables(List.of(apple1,pear1,egg1);

        Vegetable apple2 = new Vegetable(2, "apple2", 2);
        Vegetable pear2 = new Vegetable(22, "pear2", 22);
        Vegetable egg2 = new Vegetable(222, "egg2", 222);

        Farmer farmer2 = new Farmer();
        farmer2.setFirstName("Name2");
        farmer2.setId(2);
        farmer2.setLicense("license2");
        farmer2.setLastName("LastName2");
        farmer2.setVegetables(List.of(apple2, pear2, egg2));

        List<Farmer> farmerList = new ArrayList<>();
        farmerList.add(farmer1);
        farmerList.add(farmer2);

        //List<String> farmerNames = farmerList.stream().map(farmer -> farmer.getFirstName()).collect(Collectors.toList());

        farmerList.stream().flatMap(farmer -> farmer.getVegetables(

so now i can use flatmap, right? bc i have a list of lists?

T

tjoener•1/26/24, 12:53 PM

yes

Ttjoener yes

B

bambizas19OP•1/26/24, 12:55 PM

ok. thanks. but i dont understand what im doing wrong here

        farmerList.stream().flatMap(farmer -> farmer.getVegetables());

farmerList.stream().flatMap(farmer -> farmer.getVegetables());

        farmerList.stream().flatMap(farmer -> farmer.getVegetables());

farmerList.stream().flatMap(farmer -> farmer.getVegetables());

Bbambizas19 ok. thanks. but i dont understand what im doing wrong here ` farmerList.s...

J

JavaBot•1/26/24, 12:55 PM

If you are finished with your post, please close it.
If you are not, please ignore this message.
Note that you will not be able to send further messages here after this post have been closed but you will be able to create new posts.

Bbambizas19 ok. thanks. but i dont understand what im doing wrong here ` farmerList.s...

T

tjoener•1/26/24, 12:57 PM

check what flatmap wants

T

tjoener•1/26/24, 12:57 PM

It wants a function that returns a stream

T

tjoener•1/26/24, 12:57 PM

a collection (or a list) is not a stream

Ttjoener It wants a function that returns a stream

B

bambizas19OP•1/26/24, 12:58 PM

how do u know?

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

T

tjoener•1/26/24, 12:59 PM

? extends Stream

Ttjoener ? extends Stream

B

bambizas19OP•1/26/24, 1:00 PM

doesnt it mean that Function takes two things? wildcard extending a type, and wildcard extending a stream?(idk what that even means)

T

tjoener•1/26/24, 1:00 PM

No Function doesn't change, one return value with one parameter

T

tjoener•1/26/24, 1:01 PM

Don't worry about the ? extends or ? super too much

T

tjoener•1/26/24, 1:01 PM

Just ignore them for now

Ttjoener Just ignore them for now

B

bambizas19OP•1/26/24, 1:02 PM

ok. so i have to provide a

mapper

mapper

mapper

mapper for

flatmap

flatmap

function. And what is the data type of the

mapper

mapper

mapper

mapper? that whole

Function<...

Function<...

Function<...

Function<... things is very confusing to read and understand

T

tjoener•1/26/24, 1:03 PM

If you ignore the ? super and ? extends, it's basically

Function<T, Stream<R>>

Function<T, Stream<R>>

Function<T, Stream<R>>

Function<T, Stream<R>>

T

tjoener•1/26/24, 1:03 PM

That should be understandable

Ttjoener That should be understandable

B

bambizas19OP•1/26/24, 1:04 PM

not very clearly tbh. i see that for this interface, if i want to write a lambda (for example) i need to comply to

apply

apply

method

B

bambizas19OP•1/26/24, 1:05 PM

but i dont understand how to comply to Function<T, Stream<R>>?

T

tjoener•1/26/24, 1:06 PM

So basically, the T here, becomes the T from the flatmap parameter, the R becomes the Stream<R> from the flatmap parameter

T

tjoener•1/26/24, 1:07 PM

I think you need some good generics/lambda/stream tutorials, becuase you asked the same questiosn yesterday about map

Ttjoener I think you need some good generics/lambda/stream tutorials, becuase you asked t...

B

bambizas19OP•1/26/24, 1:09 PM

but i know how lambdas and generics work. and i can write needed lambda for

map

map

map

map. but flatmap is a little bit more difficult

T

tjoener•1/26/24, 1:10 PM

Well, I'm doubtful about the generics part, because that's what you just asked

Ttjoener Well, I'm doubtful about the generics part, because that's what you just asked �...

B

bambizas19OP•1/26/24, 1:11 PM

generics are used when u want ur method to be able to accept/return any type

B

bambizas19OP•1/26/24, 1:11 PM

public class Generic<T> {
    T object;

    public void createList(){
        List<T> genericList = new ArrayList<T>();
        genericList.add(object);
        System.out.println("my list is: "+genericList.get(0));
    }
   }

public static void main(String[] args) {
        Generic generic = new Generic("AAA");
        generic.createList();
    }

public class Generic<T> {
    T object;

    public void createList(){
        List<T> genericList = new ArrayList<T>();
        genericList.add(object);
        System.out.println("my list is: "+genericList.get(0));
    }
   }

public static void main(String[] args) {
        Generic generic = new Generic("AAA");
        generic.createList();
    }

public class Generic<T> {
    T object;

    public void createList(){
        List<T> genericList = new ArrayList<T>();
        genericList.add(object);
        System.out.println("my list is: "+genericList.get(0));
    }
   }

public static void main(String[] args) {
        Generic generic = new Generic("AAA");
        generic.createList();
    }

public class Generic<T> {
    T object;

    public void createList(){
        List<T> genericList = new ArrayList<T>();
        genericList.add(object);
        System.out.println("my list is: "+genericList.get(0));
    }
   }

public static void main(String[] args) {
        Generic generic = new Generic("AAA");
        generic.createList();
    }

T

tjoener•1/26/24, 1:12 PM

Yeah but the whole ? super ? extends is a big part of generics

T

tjoener•1/26/24, 1:13 PM

Basically what those mean:
? super means that whatever you're presenting needs to be that type, or any parent of it
? extends means that whatever you're presenting needs to be that type, or any subtype of it

B

bambizas19OP•1/26/24, 1:13 PM

upper and lower bounds

Ttjoener Basically what those mean: ? super means that whatever you're presenting needs...

B

bambizas19OP•1/26/24, 1:13 PM

correct

T

tjoener•1/26/24, 1:13 PM

See, you get it

B

bambizas19OP•1/26/24, 1:14 PM

not really. i cant put everything together into one place

0

0x150•1/26/24, 1:14 PM

basically:

? super something

? super something

? super something

? super something means that the generic type accepts any parent class of

something

something

something

something, eg with

something

something

something

something being String, the generic bound

? super String

? super String

? super String

? super String would accept either String itself, or CharSequence for example. Read:

? super X

? super X

? super X

? super X means "i can assign a value with type X to a variable having that generic type"

? extends something

? extends something

? extends something

? extends something means that the generic type accepts any child class or

something

something

something

something, so in the exact other direction.

? extends X

? extends X

? extends X

? extends X means "i can assign a value of that type to a variable of type X"

B

bambizas19OP•1/26/24, 1:14 PM

i have theoretical knowledge, but cant even write a lambda that complies to the needed functional interface

T

tjoener•1/26/24, 1:14 PM

In flatMap they do that so that if you have a method that takes a charSequence as a parameter, I can apply that on a stream of strings, because a String is a CharSequence

T

tjoener•1/26/24, 1:14 PM

That's the ? super

T

tjoener•1/26/24, 1:15 PM

And the return value needs to be at least a Stream, and the types of that stream need to be at least what I want the flatMap operation to return

T

tjoener•1/26/24, 1:16 PM

If I want it to return a Number, I can pass in a method that returns Integer, because Integer extends Number

Similar Threads

Similar Threads

Similar Threads