This course will be retired on June 1, 2025.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
The List collection type is much easier to use than an array, however, it has the same performance limitations.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
[MUSIC]
0:00
In the previous video we learned that
arrays can be unwieldy when it comes to
0:04
adding and removing elements.
0:09
The list collection type,
on the other hand, is much easier to use.
0:12
Adding or removing elements in a list
is as easy as calling a method.
0:15
We can find the list collection type in
the System.Collections.Generic namespace.
0:20
It's a very commonly used namespace.
0:25
So the C# REPL already has
a using directive for it.
0:27
Normally we'd want to put using
0:31
System.Collections.Generic at
the top of our file.
0:34
But because we're using the C# REPL
we don't need to do this here.
0:40
Let's create a list of student names.
0:45
To create a list just type List and
then an opening angle bracket.
0:48
Here we put the type of the items
we'd like our list to contain.
0:54
So in this case, it'll be string.
0:57
Now we need to give our
list variable a name.
1:01
So we'll say student or students.
1:03
students is just a variable
that can hold a list object.
1:08
We still need to instantiate a list.
1:12
So we will say = new List<string>.
1:15
And then our parentheses.
1:20
The list class is a special
type of class called a generic.
1:22
This allows the list class to be
a collection of any type of object.
1:27
We simply specify the type of object
that we want the list to contain
1:31
here right in between the angle brackets.
1:36
We read this as a list of strings.
1:39
Generics are not specific
to collection types.
1:42
We can create generic classes
that aren't collections.
1:46
That's a topic for another time though.
1:49
Notice that we don't have to
specify how large the list is.
1:51
We can just go ahead and add items to
the list and it will grow as needed.
1:56
To add an item to the list,
we call the add method.
2:02
So I'll say students.Add and
we'll add Sue.
2:05
If we inspect the students list
in the REPL we'll see that
2:12
it now contains one item.
2:17
Let's add a few more student names.
2:19
So I'll say students.Add("Bill"); and
2:22
students.Add("Allen");.
2:28
The add method appends items
to the end of the list.
2:35
We can see how many items are in
the list by calling the Count property.
2:38
So we'll say students.Count.
2:42
Notice that we use the Count property
instead of length like we did with arrays.
2:47
We can index into a list the same
way we did with arrays though.
2:52
So students at index 0, at index 1.
2:56
And we can get the last item
in the list by using Count-1.
3:03
So we'll say, students[students.Count-1];.
3:06
Notice that the items stay in
the order in which they're added.
3:14
So what's happening here?
3:17
You might be wondering how we're
able to add items to the list.
3:19
And the list just seems to
grow to the size we need.
3:23
The list collection has another
property that gives us a clue as to
3:25
what's happening.
3:29
Let's call the capacity
property on our list.
3:30
So I'll say students.Capacity.
3:33
Hm.
3:37
We've only added three
items to the list but
3:38
this says that the list
has a capacity of four.
3:41
The truth is the list collection is
actually just a wrapper around an array.
3:45
Underneath the hood our items
are all stored in an array.
3:50
When we first declare a list,
the array is null.
3:55
The first time we add an item to the list,
an array of length
3:58
four is created to store that item and
up to three future items.
4:01
This is why the capacity
of our list is four,
4:06
even though we've only added three items.
4:09
Let's see what happens when we add a
fourth and then a fifth item to the list.
4:12
So I'll say
4:16
students.Add("Beth"); and
4:19
Mary.
4:28
Now when we check the count,
we'll get five.
4:30
But when we check the capacity,
We get eight.
4:36
The list has doubled in
capacity from four to eight.
4:42
When we added the fifth item, there
wasn't enough capacity to store the item.
4:46
So instead,
it created a new a array of length eight.
4:51
It then copied all of the items from the
original array to this new larger array
4:56
and then added them.
5:01
Each time the list runs out of
room in the underlying array,
5:02
it creates a new array that's twice
the size of the original array.
5:06
And copies over all the items.
5:10
If we were working directly with an array
we'd have to do this work of growing
5:12
the array ourselves.
5:16
A list essentially works the same way
an array does but it's easier to use.
5:17
We can just add items to the list
without thinking about its capacity.
5:23
Lists aren't necessarily more efficient
than arrays in terms of performance.
5:27
Setting and retrieving values from
a list is still relatively fast.
5:32
However, adding and removing items
from a list can be very slow.
5:36
It's a good practice to first estimate
how large the list will need to be
5:40
in order to contain all of the items.
5:44
And then instantiate a list
that's at least that large.
5:46
We can pass the capacity
to the list constructor
5:50
to tell it how large to
make the underlying array.
5:53
So we can say List<string>
students = new List<string>.
5:56
And then we can pass in 500 here.
6:05
Or anything we want.
6:12
Now that we have a list with the capacity
of 500 adding items takes little
6:17
extra overhead.
6:22
If your estimate is too low, don't worry.
6:23
All that means is the list
will need to grow, but
6:26
this will be handled automatically for
you.
6:28
The fact that the underlying
array is encapsulated
6:31
inside of the list object
is another huge benefit.
6:35
This solves the object reference
problem that we discussed earlier.
6:38
Other parts of the program don't have a
reference to the underlying array object.
6:42
Instead, they have a reference
to the list object.
6:46
So the underlying array can be
swapped out as often as we want.
6:50
And we don't have to worry
about updating all the other
6:54
variables that are referring to the list.
6:57
Because lists behave so
similarly to arrays,
6:59
they can be used in almost every
situation where we would use arrays.
7:02
The advantage of using a list
is in their ease of use.
7:07
This makes them the most common
collection type used in programming.
7:10
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up