We currently have two array examples that we've been exploring.

They're pretty similar but slightly different.

Now first, we have golf scores.

We know that we have a fix number of holes, 18.

But we don't know what those scores are the moment that we create scores array.

Our other example, the friends going to a movie together.

We actually do note who the friends are at creation time.

Now when you know all the values of an array,

you really should use what is known as an array literate.

It saves a lot of typing and it's actually quite concise.

You're gonna love it.

Let's go take a look.

So go ahead and get your workspace up and running with jshell.

The declaration of the array actually still looks the same.

So we have a String of friends.

Now what looks different is the way that we set the values.

So what we do is we open up with a curly brace, and

let me type in the values separated by comas.

Now, note that these are curly braces other programming languages tend to

represent this bit here as a hard bracket, but Java uses curly braces.

Now, that's pretty clear, isn't it?

So, it sets each index in the order of the values here, right.

So this is 0, 1, 2, right?

So, we can do friends 0, get the first one out, and then it's gonna be Pasan.

And we can use the up arrow, we can look and we can get Alena out too, right.

And also, what happens is it automatically get set,

the length to the amount that you passed in, automatically.

Pretty handy, right?

So one thing I wanted to point out that this declaring and

initializing on the same line, gave us some extra powers.

If you declare that array first and

don't initialize it, you need to also declare its type, so let's do that.

So, let's say that I wanted to get snacks from the snack, so

we're gonna have an array of snack name and so we'll call it snacks.

Okay, and I'm not gonna initialize it, just declare it.

And then later let's say that I wanted to use it.

Now, one would assume that you can probably just say snacks =,

let's see, we wanna gonna get nachos.

We want some Sour Patch Kids, obviously,

probably need that Snickers, and I think we need a large popcorn.

Here we go, that sounds good.

So you would think that you could just do this,

but what you'll see is you'll get this illegal start of expression.

So this'll happen to you for sure.

Now, what's happened here is on the one liner this type has been inferred,

it could figure it out automatically.

Here though not so much, but here's the work around.

So I'm gonna go ahead, I'm gonna press the up arrow.

And I will preface this, move our cursor over here,

we're gonna preface this with a new string array.

Here we go, and now it knows the type and now it will work fine.

So this typed literal style is also a great way

to pass an array into a method that takes an array as a parameter.

This way you don't need to create a new variable, you can just do this.

You can just say new string and then curly braces the values, there you go.

That you way, you wouldn't need to create a variable.

And it makes an anonymous or unnamed array for you.

Well, we'll explore this in a bit.

This next looks so good.

I guess I should've asked the others what they wanted.

So now that we know how to declare, initialize, and

access elements of the array, we are ready to start using them more programmatically.

We have this wonderful populated data structure

now all stored in a single variable.

Why don't we start looping through it showing off one of its main benefits.