Okay, so first things first, we're gonns need to set our language level to eight.

By default, probably things are set to seven.

Most editors keep themselves pinned to a current language level just to make sure

that others using your code know what they can and can't use.

So, let's check it out.

So if we go File > Project Structure, and here under Project,

you'll see the project language level.

And just like I thought, it was limited to seven.

So let's go ahead and let's flip that to eight.

And we'll click OK.

You'll notice now that this turned gray here.

Then what this is saying,

is it's saying that the new comparator book can be replaced with a lambda.

Let's open that up just a little bit more.

It says, this inspection imparts all anonymous classes,

which this was, which can be replaced with lambda expressions.

Okay, cool, so let's just do that.

Let's leave this reference here, for what was there, and we will dupe this.

And let's make a new method that will accomplish the same thing.

Like Def Leppard said, let's pour some sugar on it, syntactic sugar, that is.

So I'm gonna show you a long-form class first.

So we'll call this usingLambdasInLongForm.

Okay, so what we're gonna replace is we're gonna get rid of this comparator that we

have going on here.

So I'm gonna get rid of this.

So the first thing that we wanna do here is put a pair of parentheses, and

inside of these parentheses is where we define our parameters.

So the parameters that we know from before that were

being requested was there was this book.

There's a book and it was called b1, it doesn't have to be,

it can be called whatever.

And b2. In order to say that this is a lambda,

what we want to do is we want to make a little arrow.

You do a minus and then a greater-than sign.

See how it looks like an arrow?

And then we can use the curly braces, just like we did before, and

we can do the same code that we had before too as well.

So we'll just copy this, and paste that here.

Cool, so let's go ahead and we'll change this to say, usingLambdasInLongForm.

We'll save it and we'll run it.

Okay, cool, it's still working.

That's definitely some space savings line-wise, right?

We didn't have to declare the new type, the comparator book,

it just kind of figured that out.

And we also didn't have to declare the method name which was compared,

it also figured that out right?

It doesn't say anything about the method name being compare or

that it's the comparator interface.

But we can make this even more concise.

So, if you've come across some of these before you were probably wondering what

the heck was going on, I know I did the first time I saw them.

So let's go ahead and let's dupe this method into a short form.

So, we'll say public static in ShortForm this time.

Okay, so the compiler can actually figure stuff out

well enough that you don't even need to declare types.

So, let's get rid of those, right.

So, it knows that it's expecting two books.

So, let's get rid of that.

Okay, cool.

Now, if you have a single line method, you actually don't need the curly braces.

Let's go ahead and get rid of those.

You put this all up on the next line.

When you only have a one-liner you actually don't even need the return

keyword, it knows what's expected to be returned.

So, let's get rid of the keyword.

Return. And let's bring this up a line, cool.

So that one-liner is called an expression type body.

This creates a function that accepts two books, and

returns the value from this statement here.

Let's make sure that we change this to say usingLambdasInShortForm.

All right, so let's run it.

Cool, it still works.

Pretty succinct, right?

Now, like I mentioned,

these opened up a new style of programming known as functional programming.

We're not gonna delve to deep here, we'll cover that fully later in another course.

But, let's get a quick little sneak peak.

So, the collections framework really benefits from functional programming.

And one super cool thing that got added is the forEach method on collections.

It takes a consumer, which is a newly introduced functional interface,

remember that's the new name for a single abstract methods.

Now, a consumer expects a parameter that takes one of its container's types.

So, let's replace this forEach loop.

So, we'll do books.forEach, which is the new method.

And, it takes a consumer, so the consumer is book.

And for each one of those books, we're just gonna print out.

Cool, so now if I run it, still working.

All right, are you ready for even more succinctness?

When you just have one parameter, you don't even need the parentheses, so

let's get rid of this cuz there's only one.

So it's saying for each book, run this.

So since we're here, I wanna show you one more thing that you might come across that

might look a little bit foreign, and that's called method references.

Let's take a look in the next video.