So we now have the ability to take a collection of items, and

gather a portion of those into another collection.

That works well, but a lot of time in the reality of our code base,

what we are actually needing to do is collect our subset of items, and

then produce different representations of those same items.

For instance, maybe we want to populate a drop down list in an application,

with just a name of those items.

Maybe we want to produce some mastered detail representation on our webpage,

we're we show a paginated list of items as links.

And clicking on that link will go to a more detailed page.

Streams add some real power, because instead of making a separate collection of

the items, you can actually transform the item

as it's passing through your functional pipeline, in one foul swoop.

It's pretty powerful.

There is a bit of a naming collision unfortunately, so

the method name that we're going to use on our stream is named Map.

Now this unfortunately, is the same word that we use for

our key value data structure, map.

Like a HashMap.

And I'm bringing that up now, so you don't confuse the two.

The map is used to transform or map one item to another one.

So, similar to how filter used the predicate functional interface,

map uses the function functional interface.

The single abstract method is named Apply,

and the signature is that it takes a single value and returns a value.

Ready?

Let's put the functions on the map.

Bad idea to throw in another map there.

Sorry about that.

So the job output is a little tacky currently.

So, let's do this.

Let's assume that we have a page in our application,

where we want to give an example of the jobs available.

So, let's show off three junior jobs but let's format that a bit prettier.

So imperatively, let's do this.

Let's copy the imperative method that we used to get the first three.

So let's copy that and then paste it.

So we're gonna copy it, give us some space here, copy this.

And let's paste it here.

And, so now let's go ahead and let's rename that

to getCaptionsImperatively, so we'll pull a caption out there.

So getCaptionsImperatively.

And instead of returning a Job, we'll return a String this time.

A List of strings, so

the caption instead of that long string mess there, will make it prettier.

So now, this is complaining we need this to be a String.

I'm going to go ahead, I'm going to rename this refactor rename.

And we'll call this captions.

So let's make a pretty caption in here so we'll say, String caption and

we'll d a nice format string, so we'll do format, and

we'll say the company is looking for a Job title and location.

That's a pretty nice caption.

So let's see.

Let's break that out a little bit.

So the first present s is going be job.getCompany,

and the next will be job.getTitle.

And finally, we'll do a Job.getCity.

Go ahead and supply add a caption here.

Cool, and then it will return the captions.

So we now have getCaptionsImperatively, so let's go use it.

Let's make sure it looks pretty.

So we'll say get.

CaptionsImperatively, we'll run the jobs through there and let's take a look.

Beautiful, looks a lot better.

Now, let's see what this looks like stream wise.

So that was here, we'll get these three junior jobs.

And I'll move this down so that we can keep them together.

Say.

GetThree, let me change this to be captions.

GetCaptions.

Stream, and of course we also need to change this to now be a list of Strings.

Now, check out this error that we've created.

See how this list here knows that it's supposed to be returning a String,

but in fact we are returning a Job.

So, we need to transform our Job into a String, and

we do that with the map method.

So, let's go, let's Job, let's do it.

So we will come here.

So we're sure that we have a JuniorJob, then we're gonna do a .map.

And you'll see that it takes a function.

So if we take a lambda, we'll be getting in a job, a JuniorJob for

sure because it's been focused that way, and

then we will just take that same code that we did here.

What we did here the String format will.

Remember, it will automatically return a String.

I don't have an extra one in there.

Let's bring this up here, and then we'll close our map out, there we go.

And if we come up to our example, our explore up here and

we change this to Stream, let's see how we did.

Awesome, but we've duplicated this code.

And we've duplicated this string format code.

Now, chances are we're not gonna be the only ones needing it.

So, we could make a static method or why don't we do this,

let's make a computed property on our job object.

It seems like others might want to do this.

So I'm going to grab this from here.

We'll cut this out, and

let's just say job.getCaption.

And it won't exist, and then we go create it.

So we create for that.

And this is going to return a String.

And it's going to return the String.format.

Get rid of these.

Jobs here, and put a semi-colon.

So now, we have.

What we need.

And over here, it will return job.getCaption.

And let's go ahead, and we'll clean up our imperative one.

So, what we'll do is we'll say captions.add.

Job.getCaption.

There that is prettier.

So now if a job passes through and it is a JuniorJob, it's gonna come into map.

Map is going to take a Job, and it's going to return a String.

So it's going transform into the String of the caption, and

then it's going to go through.

And that's the apply method of function.

It's going to take a type, and it's going to return a different type.

Or whatever, it's going to return something else.

So, it took in a Job, it returned a String, and

we know that it's a String now.

So look here, there's an intention action light bulb, let's go ahead and

see what it says, it says replace lambda with method reference.

Good, we love method references, let's do that.

Wow, [LAUGH] hat looks great.

But wait a second, getCaption on the Job class doesn't take a parameter.

It doesn't take a parameter, it's just empty, so how is that working?

I mean isJuniorJob, this method here,

isJuniorJob, that takes a Job and returns a Boolean.

But, getCaption doesn't.

Now this is a common head scratcher, and

the reason is because it depends of the type of method.

This isJuniorHob, this is static.

However, this getCaption method is on a Job instance.

You can't execute the method without an instance of a job.

Method references know that, so

the implicitly require an object to execute the instance method on.

So really, you can picture any method reference that is referring to an instance

method, like our getCaption method here as a function that expects an argument

that is the instance of the type that has that method on it.

So Job, it's always assuming a Job is passed to it.

So, the Job that comes through this filter is passed in here.

And getCaption is run on that Job.

Otherwise, how can the method run?

If that wasn't clear, go ahead and rewind me a bit.

It's a little strange of a concept, and it's okay for

it to take a while to sink in.

You'll see this quite a bit when map is used.

Especially when trying to just get a getter,

transforming an object to one of its properties.

Actually, that is known as method reference inference, and

we can cross that off our parking lot.

So let's go over there.

So Method Reference Inference, let's go ahead and

we will do a Strikethrough, perfect.

So, let's take a quick break and when we return we'll talk about what happens

when you encounter a value that maps to a stream from within your streams.

Yo dog, I heard you like streams in your streams.