Which collection class?
Video lecture: hash tables
Using collections in Java (1)
In this section, we'll give a fairly practical introduction to using some of the
main Java collections classes. We'll start with the simple case
of a list.
What is a list?
OK, it might sound a dumb question, but when we refer to a list
in Java, we mean specifically a collection of objects that:
- has a fixed order (when we add an object to the list, it will
stay in the place we put it);
- allows objects to be referred to by position, so we can
get or set the "4th element in the list";
- generally speaking, does not have a fixed number of elements,
unlike an array.
A plain old array has the first two of these properties, but not the third: when
we create an array, we always have to say how many elements it has, and we can't change
this number once the array is created. The third property isn't
strictly speaking a necessary property of a Java List. But in practice,
the most commonly used types of List are
used instead of a plain old array because they have this "unbounded" property.
Using a List in Java
As with Java collections generally, there isn't actually a single Java class called
List1. Instead, there is an interface called List,
with various implementations. So a typical way to create a list would
look like this:
List<String> myList = new ArrayList<String>();
In the above example, we import all classes from java.util, which is
where List and ArrayList reside. Unless
otherwise stated, assume that all of the collections classes we mention from now on
are in the java.util package, and you will need to import them.
In this example, the actual collection object that we create is an ArrayList.
This is a list implementation that stores objects inside an array. Although arrays have
to be fixed-size, ArrayList internally handles this by creating a new, bigger
array where necessary and copying the previous elements into the new array. So to the
caller, what we effectively get is a list with no fixed size which we can add to and
remove from arbitrarily.
Notice that we also state, inside angle brackets, that the list will specifically
hold objects of type String. If you haven't come across it before, this
syntax was introduced in Java 5, part of what is technically called the generics
framework; we'll introduce more details as we go along.
Now we have our list, we can start doing interesting things with it such as
adding and removing elements. Any List
provides various methods, including add(), get(), size():
System.out.println("The list contains " +
myList.size() + "elements, and " +
"the first is " + myList.get(0));
A key feature of Java used in the collections framework is the notion of
interfaces and implementations. An interface
is a "blueprint" for a class: it specifies a series of methods, but does not
contain any code inside those methods. For example, the List
interface includes the methods add() and size(). This means that
any class that wants to be a list implementation must include an add() and a size() method,
but doesn't state how individual classes should implement these methods (i.e. what code
goes in the method). That's up to individual classes. For example, the ArrayList class
implements its add() method by putting the object in its underlying array.
The LinkedList class implements its add() method by adding the object
to the end of its linked 'chain of objects'. The advantage of having interfaces is that
we can write code that is more 'general': we can write
code that operates on "any sort of list", always referring to the object in question
as a List (the name of the interface), without having to worry about whether it's
specifically an ArrayList or a LinkedList that we're dealing with
in any one case.
For more information, see the separate section on interfaces in Java.
Lists provide various other useful methods, such as for removing items
from the list, adding at a specific position, or determining the first or last
position of a particular item in the list.
On the next pages, we continue by looking at:
1. OK, there's an AWT component also called List, but that's
not what we're talking about here...!
Written by Neil Coffey. Copyright © Javamex UK 2012. All rights reserved.
If you have any feedback on the Java collections tutorials in this section or about the content of this
site in general, please leave a message on the Javamex forum.