An array is a data structure which stores a collection of elements and

has a fixed sized.

An array buffer on the other hand, gives us the same features as an array but

provides flexibility in terms of size.

The array buffer can grow and shrink as we need.

Let’s dive into the code and get comfortable with both.

Lets fire up IntelliJ and create a new package within our Source directory.

Right-click on Source, select New > Package.

Provide a package name, in our case collections.

And then we'll copy our SuperHeroes object.

And paste it into our collections package, click OK.

And within our SuperHeroes object we can get rid of everything but

our main function.

We will use this object as our main class to run all of our operations.

But in order to do so we will also need to edit our configurations.

So we'll click Edit Configurations, and for our main class,

we'll select the SuperHeroes in the collections package.

Click OK, and then Apply, and OK.

There are a few different ways to create an array.

Let's dive into how arrays work by implementing them.

Great, we create the array by supplying the new keyword, followed by array,

the type, and also the array size.

Here we've created an array of integers called numbers with length 10,

all initialized to the integer 0.

Similarly, we can create an array of all strings

Again, we supply the new keyword, the array keyword,

the type information, and the array size.

Often times we may want to create an array with some initial values.

In that instance we don't need to provide the new key word.

Let's take a look.

You may have noticed that we don't have to specify the type that's because

Scala's type inference can in further type from the values we passed to the array.

A big different from Java and many other languages,

which you may have used to access values at a specific index of the array,

we use parenthesis instead of square brackets.

Arrays are 0 index and we can access the fourth element by using the parenthesis.

In this case this should print out Batman.

Let's compile and run our application, awesome.

One issue that we will encounter is adding or removing elements from our heros array.

Let's say we wanted to add Iron Man to our list of heroes.

We can use the colon plus method on our arrays.

However, this would create an entirely new array.

Array buffers to the rescue.

To create an array buffer we need to import the scala.collection.muteable

package or specifically the array buffer class within the package.

Let's do so at the top of our file and create a new array buffer.

[SOUND]

Awesome.

To add a new element to the ArrayBuffer, we would use the += method.

Additionally, we can add multiple elements by enclosing them in parentheses

Similarly, we can add an entire collection by using the plus plus equals method.

Let's create an array to append to our mutable heroes.

Awesome, here append other heroes to our mutable heroes.

Arrays and array buffers have a ton built in functions you should get familiar with.

I've included links in the teacher notes to the actual documentation.

Remember our array buffer is mutable.

So let's run a few operations on our heros to get more familiar.

Let's print out the contents of our array buffers so

we have an idea of what it's currently storing.

Awesome. We see that we have an array buffer

with all the values that we've added to it.

Additionally we can remove a number of elements starting from the right

of the array buffer.

TrimEnd allows us to remove a number of elements starting from the end of

the array buffer.

In this case we make use of the update method which lets us update the value at

a specific index.

Therefore replacing Thor with Flash.

Let's reprint the contents of our mutableHeroes array and

see how things have changed.

Rerun our application.

And the first thing we notice is that Thor has been replaced with Flash.

Additionally, we notice that Starfire, as well as Green Arrow, have been removed

from our array buffer Awesome we learned how to create arrays and array buffers.

Now let's traverse through our mutable heroes array buffer.

As we previously covered we can use the four loops in Scala

to loop through an array or an array buffer.

We'll comment out our previous print line statements.

Here, we follow the left arrow operator,

which loops through each element in the array buffer.

Let's recompile and rerun our app.

Great, now we've printed out every element in our mutable

heros array buffer to the screen.

If you recall from an earlier lesson, Scalas supports inclusive and

exclusive ranges.

For an exclusive range, we use the keyword until.

Let's recompile and run our app.

Awesome.

We notice that our result, 10, is not included.

For an inclusive range, we have to use the keyword to

Let's recompile and run our app.

Great and in this case we see that 10 is included.

However there may be certain instances where we'd also like the index values.

In this case we print out the index and the value of the specified index.

Until provides us with an exclusive range, so

there's no need to subtract one from the array buffer length.

Awesome, as expected we get the index value along with the element

at that index.

With an inclusive to,

we will need to subtract one from our mutableHeroes length.

Otherwise, we would get an index out of bounds error.

In earlier videos we learned about four comprehension and guards.

These concepts are very useful when transforming arrays.

Let's create a new array with any heros whose name contains a dash.

The yield keyword will create the same type of collection as the one we start

with and the guard will provide filters on our data to any element in the array

that contains a dash.

Let's see how that works by printing out the element

in the dash heroes array buffer.

As expected, our dash here as array buffer only contains one element,

Spider-man, as it's the only element that has a dash in its name.

Great, we learned how to create, traverse, and update arrays and array buffers In

the next video we'll focus on another set of data structures called list and

list buffers.

See you there.