[MUSIC]

[SOUND] Now that we've seen the power of arrays,

it's time to look at some of their limitations.

Now, we've been dealing with arrays where we either know all of the items at

declaration time or at least we know how many there will be eventually.

In reality, that's not always the case, is it?

I'm sure you can imagine programs where we're taking input from a user, and

they want to either add or remove elements from the array.

Now, if you recall when we first started talking about this

fancy new data structure, we talked about how it's length is immutable.

Now remember, that means it can't be changed.

And the reason for this immutability was because the declaration required

all of the elements to be one after the other, contiguous.

So that brings up quite a big gotcha.

In order to add an element,

you would in fact have to change the length of the array, and you can't.

So, what do you do?

Well, the answer is you copy that array into a brand new one,

that includes the needed space for you new element.

In fact, I have a pretty good example of how this can creep up.

In our list of friends, I forgot to add myself.

Let's take a look at how to handle this common gotcha.

Okay, so I'm gonna do this is JShell.

So I'm gonna use the scratch file.

What I'm gonna do, is I'm going to grab this string friends array here.

I'm gonna copy that, and I'm gonna pop it over into the scratch file.

I'm gonna get JShell up and running.

While we do this, Jshell will be running.

And then scratch, I'm gonna just erase what we have here.

I'm gonna drop our front array in there, cuz it's a scratch file, right?

It doesn't really matter.

You can put whatever you want in here, and then we can open it up and use it later.

That's the idea, and we explore around.

Okay, let's do it.

Let's get that file in there.

We'll say open scratch.java.

And then we'll type friends.

Awesome, okay.

So the goal is to add me to the end of this list.

We wanna attend me.

So there are couple of approaches.

Now the first thing you do is create your array to what size you want.

And let's do that, so let's see.

It's gonna be a string array.

It's gonna be a new string array.

We'll call it friendsAndMe, great.

And then we'll do = new string.

And we want one more than's there, cuz I'm gonna come to this party, now so

there's [4].

There we go.

So you'll notice that it defaulted all here to null,

which is the default for objects.

Okay, and then what we wanna do is we wanna copy all of the elements from our

original array into this array.

So the method itself is a bit on the older side of Java.

It's been around forever, and

it's dangling off of a system class.

It's called array copy.

So if I just start typing arr and I press tab, it will go ahead and fill it out.

Now, one thing that you might not know about JShell, and I really like this about

JShell is if I press tab again, it will actually show the documentation.

The first tab, it shows just the signature.

And the second time, it's gonna show the documentation for that, and

press tab again.

So it shows the method declaration which is important,

cuz we need to know these signatures are.

We need to know about this here, what the names of these are, what they mean?

They're not the greatest, but okay, so source is the source.

It's what we're trying to copy, so that's our original array.

Original array is friends.

All right, source pause.

[LAUGH] That's the position, right?

So that's the starting index of where we wanna start copying from.

So the position of that is 0, so we wanna start the very first element.

Okay, and then the next parameter here is the destination array.

So the destination array that we want is the one we just created.

So we wanna copy that to friendsAndMe.

And the next is the desk post, so the destination position,

where do you wanna place that two?

And since we're just copying over, we want me at the end, we'll start at 0.

And finally, the link.

How many of those items from the first one do you wanna copy over?

And I'm just gonna use friends.length, saying that we wanna copy them all.

Okay, so now, if we take a look at friendsAndme,

we'll see that we have an extra space at the end here, where we can put me.

So I wanna put myself in that last one there.

So let's say friendsAndMe[3] = "Graig".

I'll go ahead and pop that to the top here.

And there we go.

So that's quite a bit to remember.

And I'm gonna bring this back, so we can take a look at it.

That's quite a bit to remember.

Now, there's actually another approach, that's a little bit better.

And it's actually really similar to what we just did.

There's a helper class, which provides a lot of helpful methods.

However, it's not readily available like our system one was.

We need to actually import the class to use it.

Now, if importing is new to you, check the teacher's notes.

For right now, though, let's just do this line.

Let's do an import here.

Erase this line.

I'm gonna say, import java.util.Arrays.

So that's gonna bring this class into our scope here.

And there's a static helper method off of this class called copy of, and

it makes copy of your Array.

So let's just use it.

So a String array called friendsAndMe2,

And we'll access this Arrays.

And off of that, we will access copyOf.

And copyOf this time is camel case.

And what that takes is, it takes the source array, which is friends.

And you tell it how long you want the new array to be.

This is a little bit different.

So we're gonna say that we want a new array to be friends.length.

And we want it to be one more, cuz that's what we're gonna add, so + 1.

So there you go.

It's basically the same thing, it's a little more succinct.

Now, the important think to recognize here is that in order to make a change

to an array, you need to manage the copying of it.

Now, the arrays of value,

you basically just don't copy it over to your new copy of the array.

Essentially removing it, it's a little gross.

Check the teacher's notes for more.

So how'd that feel?

A little gross, right?

Well, the good news is there's a solution to this.

As the old saying goes, if it hurts when you do that, don't do that.

When using arrays, you actually very rarely ever do any adding or

removing of elements.

This is because in practice,

there is another data structure that is known as a list.

It is intended for dynamically adding and removing values.

Now, list are out of the scope at this course.

But we'll get to them very shortly in an upcoming one, so hold tight.

Now, don't stress too much on the mechanics of adding and removing.

It's super easy to do with a list.

Side note, the most common type of list is called an array list.

And what you just learned how to do,

is exactly what is abstracted away from you for adding and removing.

It manages the array growing and shrinking, and it does all the copying.

If you just can't wait, check the teacher's notes for more information.

Now that I bummed you out a bit about arrays, let me bring back your

appreciation for them by showing off how you can control their order by sorting.