In this video, we will learn about arrays, specifically will learn about the NS array

and NS mutable array classes we find in Objective C.

So what is an array generally speaking?

Well it's an ordered collection of items where all of the items

are some type of object.

You could have an array of strings or

an array of dictionaries or even an array of arrays.

You could also have an array that mixes different types of objects.

Those items in the array are known as its elements.

As you can imagine, arrays come in handy for

storing all sorts of things like the names of every student in a classroom or

the results of some query from a database.

So I mentioned that in Objective C, we have two flavors of arrays an NS Array and

NS Mutable Array.

As you probably guessed, NSMutableArray's can be changed whereas NSArray's cannot.

Also in case you're interested, NSMutableArray is a subclass of NSArray,

so it inherits all of its characteristics except where they've

been intentionally changed.

You already know for

example that NSMutableArray has the added capabilities to have its elements changed.

That is to say, replaced, removed, or resorted.

But for now let's focus on NSArray since it's a bit simpler and

learning about it will also help teach us about its subclass NS mutable array.

So here we see NSArray of names.

We created it using the literal syntax.

That's the at sign and the brackets book ending our array.

Now let's notice a few things about NSArray.

Firstly, every element in it is the same type, N-S string.

By the way, those NSstrings are declared with the literal notation too.

That's the @ in quotation marks for those keeping score at home.

One other important thing to remember with N S arrays,

is that there elements must be objects.

By that I mean, they can't be primitive or

scalar types like ints, floats, bools or doubles.

If you want to store that type of primitive data,

you need to wrap them in NS numbers or some other Objective-C object type.

It's also worth noting that elements in an array can be repeated.

For example, in our array Kenneth appears twice.

If you were interested in creating a collection where you can't repeat an item,

you'd probably wanna use an NSSet rather than an NSArray, but

that's a horse of a different color.

Now some of you may have noticed that we created this NSArray object,

without using Aleken in it, which we just spent an entire video on.

Well that's because we use the literal notation, so

you don't need to explicitly call Alec in it.

However, you could, and then your code would look like this.

You'll probably see that alloc]init syntax a lot in older legacy code, which may have

been written before literals were used for arrays in Objective C.

You could also create that same array like No explicit Allegan in it,

but it also doesn't make use of literals.

In both of those,

it's worth noting that you need to include nill as the last item in the list.

That tells the compiler that the array has no more elements to add.

So I can get an accurate count for the array.

Before we move on it's worth pointing out that you can't create NSMutableArrays

using literal syntax for mutable or

changeable arrays, you'll need to use options like this.

And this.

And this.

Literals just won't work.

So now that we've created our shiny new NSMutableArray like,

[SOUND] what are we going to do with it?

Well, we can do lots of things to it.

We might iterate through it, replace one of the elements, or

simply retrieve one of those elements.

To do this, we need the index of the element or it's position in the array.

That's pretty simple to do, but

there is one important wrinkle you need to remember when we index arrays

the first element isn't at index one, but actually index zero.

So for our little array element at index zero is Andrew at index one you'd

find Kenneth to retrieve the element in the third spot you could simply type, and

string *name equals [ nameArray objectAtIndex; 2 ];.

That's the third element but the index is two since we started counting it zero.

Doing that retrieval will work for initializers as well,

since we aren't actually changing the contents of the array itself.

One of their common task is getting the count of elements in the array.

That's pretty easy to do, you could simply type, int arrayCount=[nameArray count];.

Now with mutable arrays,you will probably want to do more than just get the count,

let's go over some of the most common actions,

if we wanted to replace the first item with the name Gabe, we could simply type

name array replaceObjectAtIndex:0 with Object:@"Gabe".

To remove it completely, we'd simply type name array removeObjectAtIndex:0.

To insert an additional element at the third spot and

bump all the following elements by one index, we could use this syntax,

NameArray3, insertObject newName atIndex:2.

To add a name at the end of the array regardless of the current number of

elements, it's as simple as nameArray3 addObject zed.

The compiler will automatically add it to the end,

you don't need to explicitly say what the length is.

I hope you found that introduction to arrays helpful.

Don't worry if you don't remember all the syntax,

you can always go back and look it up.

It's much more important that you start getting a handle on what they are,

what they're used for, and what you can do with them.

Speaking of which, let's reinforce some of those concepts with a quick quiz, and

then move on to some hands on practice in Xcode.