[MUSIC]

In the previous video we learned that arrays can be unwieldy when it comes to

adding and removing elements.

The list collection type, on the other hand, is much easier to use.

Adding or removing elements in a list is as easy as calling a method.

We can find the list collection type in the System.Collections.Generic namespace.

It's a very commonly used namespace.

So the C# REPL already has a using directive for it.

Normally we'd want to put using

System.Collections.Generic at the top of our file.

But because we're using the C# REPL we don't need to do this here.

Let's create a list of student names.

To create a list just type List and then an opening angle bracket.

Here we put the type of the items we'd like our list to contain.

So in this case, it'll be string.

Now we need to give our list variable a name.

So we'll say student or students.

students is just a variable that can hold a list object.

We still need to instantiate a list.

So we will say = new List.

And then our parentheses.

The list class is a special type of class called a generic.

This allows the list class to be a collection of any type of object.

We simply specify the type of object that we want the list to contain

here right in between the angle brackets.

We read this as a list of strings.

Generics are not specific to collection types.

We can create generic classes that aren't collections.

That's a topic for another time though.

Notice that we don't have to specify how large the list is.

We can just go ahead and add items to the list and it will grow as needed.

To add an item to the list, we call the add method.

So I'll say students.Add and we'll add Sue.

If we inspect the students list in the REPL we'll see that

it now contains one item.

Let's add a few more student names.

So I'll say students.Add("Bill"); and

students.Add("Allen");.

The add method appends items to the end of the list.

We can see how many items are in the list by calling the Count property.

So we'll say students.Count.

Notice that we use the Count property instead of length like we did with arrays.

We can index into a list the same way we did with arrays though.

So students at index 0, at index 1.

And we can get the last item in the list by using Count-1.

So we'll say, students[students.Count-1];.

Notice that the items stay in the order in which they're added.

So what's happening here?

You might be wondering how we're able to add items to the list.

And the list just seems to grow to the size we need.

The list collection has another property that gives us a clue as to

what's happening.

Let's call the capacity property on our list.

So I'll say students.Capacity.

Hm.

We've only added three items to the list but

this says that the list has a capacity of four.

The truth is the list collection is actually just a wrapper around an array.

Underneath the hood our items are all stored in an array.

When we first declare a list, the array is null.

The first time we add an item to the list, an array of length

four is created to store that item and up to three future items.

This is why the capacity of our list is four,

even though we've only added three items.

Let's see what happens when we add a fourth and then a fifth item to the list.

So I'll say

students.Add("Beth"); and

Mary.

Now when we check the count, we'll get five.

But when we check the capacity, We get eight.

The list has doubled in capacity from four to eight.

When we added the fifth item, there wasn't enough capacity to store the item.

So instead, it created a new a array of length eight.

It then copied all of the items from the original array to this new larger array

and then added them.

Each time the list runs out of room in the underlying array,

it creates a new array that's twice the size of the original array.

And copies over all the items.

If we were working directly with an array we'd have to do this work of growing

the array ourselves.

A list essentially works the same way an array does but it's easier to use.

We can just add items to the list without thinking about its capacity.

Lists aren't necessarily more efficient than arrays in terms of performance.

Setting and retrieving values from a list is still relatively fast.

However, adding and removing items from a list can be very slow.

It's a good practice to first estimate how large the list will need to be

in order to contain all of the items.

And then instantiate a list that's at least that large.

We can pass the capacity to the list constructor

to tell it how large to make the underlying array.

So we can say List students = new List.

And then we can pass in 500 here.

Or anything we want.

Now that we have a list with the capacity of 500 adding items takes little

extra overhead.

If your estimate is too low, don't worry.

All that means is the list will need to grow, but

this will be handled automatically for you.

The fact that the underlying array is encapsulated

inside of the list object is another huge benefit.

This solves the object reference problem that we discussed earlier.

Other parts of the program don't have a reference to the underlying array object.

Instead, they have a reference to the list object.

So the underlying array can be swapped out as often as we want.

And we don't have to worry about updating all the other

variables that are referring to the list.

Because lists behave so similarly to arrays,

they can be used in almost every situation where we would use arrays.

The advantage of using a list is in their ease of use.

This makes them the most common collection type used in programming.