You're at a point right now where you've had enough time with streams and

you're probably falling in love with them.

It's okay, I won't say anything, your secret's safe with me.

Around this emotional time you wanna spent even more time with them and you'll start

saying, how they make every problem you try to solve so much more beautiful.

Okay, I was being silly but in reality you were seeing the power of streams.

And you'll start wanting to use them for just about everything.

So, I'd like to show you two important things first,

you need to know how to create a stream from objects that aren't in collections.

It's really straightforward there's a static method on the stream class called

Of, it's pretty you'll love it.

Secondly, now that you can create streams out of thin air,

you are bound to run into a common problem.

You'll try to map at them and

you'll end up pushing a stream through a stream and stuff just gets awkward.

But don't worry. There is an easy solution.

In programming, there is a concept called Flattening.

Imagine for a second that you have a list of lists.

Now this list is hard to process so what you do is flatten it,

by pushing the list down into one single list, now it's much easier to process,

see how the list is now flattened?

It could've also called it smooshed together.

We could do a similar thing with streams of streams and

it's a pretty powerful concept that is going to make you love them even more.

I know you're falling pretty hard already.

>> So first off, let me show you how to make a Stream.

So if we do Stream.of, it's so declarative and so purdy.

We'll say hello,

this is a stream.

It is in the java.util.stream package so there we go.

And since it's a stream we can do a for

each on it, our little terminal operation here and we'll to the ever so popular,

we'll just print that out real quick, system that out.

Print line.

And, boom, there it is.

So that of static method accepts what is known as varargs.

So it takes in endless amount of parameters,

as long as they are all the same type.

So you can also pass that in array.

Check the teacher's notes for more on var args, so let's do this.

On the job object, there is a little snippet of what is required for the job.

Now it's not the full description, it's just part of it.

Now that's because the indeed API,

the one that we're using, wants you to come to their site.

So I was thinking, why don't we do this?

Why don't we try to make a Word Cloud based on the different words

in that snipit.

And then we'll keep account of how many times each word appears across

each of the 1000 job postings that we have, sound fun?

Now normally, we've been taking time to build the imperative style of code to

solve the same problem.

Now it's gotten to a point where the code is too long to write in a single video.

I've already written it and it's in the teacher's notes.

So I'm gonna copy it and I'm gonna paste it right here.

And I am going to say this is indeed a Map, yes.

And that is a HashMap, yes.

Okay, so let's walk this really quick.

So I'm gonna return a map of string which is the word to the number of counts there,

so that's what we're gonna do and we're gonna make a new hash map.

We're gonna loop through the jobs and we're gonna split apart the snippet.

We're gonna split Split using a regular expression,

check the teachers notes if this is new to you.

But this is anything that is not a word, we're gonna split on that, so

that we just get the words out.

And then we're gonna loop each of the words.

So we've got a nested four loop here, we're gonna loop each one of those words,

and we'll check the length, cuz sometimes this comes back empty.

So if it is in fact empty, I could actually us is empty there.

We'll check the link.

And then we're gonna continue, right, cuz we don't want to run it through here.

We're just gonna bail out if that exists.

And then we really only want the word to be lowercase.

Right, we don't want a capital java and lower case java.

So we're just gonna lowercase it so

it's the same word, cuz case doesn't really matter in a word cloud.

And then, we are going to pull the current count, should it exist.

And this thing is here.

If it's null, that means that it's zero, and we're gonna put a new one in there.

Now, longs are mutable.

So what will return is the result of a pre-increment, right?

So this will, because this will, these are all be 1 if there was a 1 in here,

we count at 2, right?

Cuz we're doing a pre-increment.

And then finally what we return that map.

Okay, now let's use it.

So it is called getSnippetWordCountsImperatively.

So let's get rid of this stream example here.

And so we'll say getSnippetWordCountsImperatively, and

we will pass in jobs.

Now, I wanna loop through the keys and values.

So there is a collection that takes on a map and it's called forEach.

Now instead of a normal consumer, because we are getting back a key and a value,

it takes a by consumer.

So remember that's 2 values right, so

the two values that we're gonna get back from that are key, and value.

So each time that will get passed through.

Pretty nice right?

And then I'm gonna print,

let's say the key occurs %d times.

Okay, so we're gonna do key and value.

Cool, let's give that a run, let's see what happens.

Let's go ahead and put a new line on there and make that a little bit prettier.

Cool, so locations occur six times TCP will occurs 86 times.

Gotta have a lot of will.

Security 19 times, cool.

This is looking pretty nice.

All right, so let's tackle the problem declaratively using streams.

So let's copy that signature first, so let's grab this here.

And I'm gonna just put them right here and we'll say get snip it word counts string.

Okay, so we need to return a map so let's remember that we're gonna do that we're

gonna return job dot string we'll collect into a map this time that'll be fun okay,

so now we want to transform the job.

Into its snippet.

So we will say map, and we'll do Job getSnippet.

So it's gonna pass the job in, and on that job it's going to call getSnippet, cool.

So now we have a snip it, we have a string so

let's map that string, let's snip it, right?

We're gonna do just like we did before we're gonna split snip dot split and

we're gonna split on anything that is not a word and

again if that is confusing to you check the teachers note.

Okay, so what is this saying?

Probably, that we're not done yet.

Cool, so yeah, we're not done.

It says, you can't return this yet.

What are you trying to do?

So now, we have an array of words.

So we can actually create a new stream.

But we don't want to cross the streams.

Never cross the streams.

We wanna flatten it, right?

Remember that's what we were talking about, flatten it.

So we're gonna take flat maps.

So let's do that, so we'll say .flatMap and

it takes an item and that item here this are the words, all right?

And what we gonna do is stream of words.

So, remember I said stream of can take an array, so took an array words and

made a new stream.

So, the cool part is you can imagine what comes out of here

just like a brand new stream.

Anything that comes out of flatMap is like a brand new stream.

So what's going to pop out is a word, one at a time.

Right? So, let's do that.

We want to make sure, like we saw before that the word isn't empty, right?

So we'll say word, length, is greater than zero.

So now we're sure that we have a string and we want to get the lower case of that.

Right?

So we'll do .map and String as a toLowerCase.

Again, that is an instance method on Strings.

So because Strings coming through here, that's doing that

Don't be confused by the squiggly, that is just because we can't return yet.

And now we wanna collect the items.

Now before we collected into a list.

But this time remember we wanna collect into a map.

So collectors are super powerful.

So here's a little sneak peak at a pretty powerful collector called grouping by.

So we're gonna say .collect,

and we're gonna say Collectors.groupingBy.

So groupingBy requires a function that takes an item and

returns an item, just like map, okay?

So, we want this is what it's going to be for a key.

Now this is gonna be a little bit dorky but

what we want this is the function that basically just returns itself.

It's gonna get a word, it's gonna return a word.

And then the next perimeter is a collector.

So, there's a handy one called counting.

So we're gonna collectors dot counting.

Basically that does what we did in the other lab.

Then I'm gonna put a semicolon here.

Now that dorky function that we just wrote, that returns exactly what it got,

I got a word, I'm gonna return a word, pretty dorky.

It's so common that you can actually replace it with a handy static method

off of the Function class, and it's named identity.

So then you don't feel so dorky.

So you say Function.identity.

Basically it's like It doesn't do a map, it just returns what's there and that will

save you from writing that obvious lambda that you don't really need to.

This is common enough in functional programming that you just call that

the identity function.

Now one more thing that we can do to really clean this up.

Cuz, if we take a look at our flat map here.

Look what it's doing, it's taking what was here, and

it's just passing it in to another function.

Well, that's a great place, for a static method reference.

Let's do just as the intention action suggests, and replace that there.

Okay, so let's assume, that we have a few jobs here.

I'll just make one of these comments here.

So, we'll say a job that has a snippet.

And it says this is a job.

And then there's another job and it has a snippet.

And it says, also a job.

Not very helpful snippets, but here we go.

So let's walk this really quick.

We open up a stream on these two jobs, okay.

And we transform that item into a snippet.

So now it's just this.

This is a job, there's a string here, and then we map that into an array.

So then it is a four item array of this is a job.

And next we go into the flat map.

And flat map can take anything and

it expects that what is returned is a "stream".

So, pass in our array to "stream.of",

and that makes a new stream of "this is a job".

So the first item that comes through is this, and it passes the filter; we

make it lower case and then we go into the collector process and

it says hey, is there, basically what this code is doing here.

Right? It just checks

to see if it's in there and then puts it in.

So, it passes this word through and

the function identity is basically just saying this is the word here.

Sometimes you might want to translate that.

Like we could've put that in here, we could've put this map in

here to use the function, it's a lower case the thing so this goes in here, and

then it comes back to the flat map which is running, right?

So it's gonna come in and it is going to say the next word which was is.

So is is gonna come through, and then it's gonna do the count.

And then it's gonna go a, and then job.

And then it will come back up to the top.

Pretty cool, right.

So again, flatmap is an interesting concept, take some time to let it sink in.

It's really powerful and exactly what you need, when you need it.

You're doing great, if you ever find yourself with a stream of streams

you're probably missing a flattening step somewhere.

And like I said when you need it, you'll understand it.

It's like stream a little stream with me.

That collector was super powerful, wasn't it?

I love that you can express that so declaratively.

The overarching principle of processing a stream of items and

producing something new through a terminal operation is called reduction.

In the next stage, we'll dive deeper into some more handy ways to reduce your data.