ListsS2C Home « Lists

In the second of three lessons on the different collection types within the Collection hierarchy we look at three of the concrete implementations of the List<E> interface. So what type of collection is a List? Lists are ordered collections that use an index for the ordering of the elements within the collection. As such lists have methods for the index that you don't find in other collection types within the The Collections Framework. An element is added to a list by specifying the index position or to the end of the list when no index is specified.

List Hierarchy DiagramTop

The diagram below is a representation of the List hierarchy and covers the interfaces and classes we will study in this lesson. The diagram has several interfaces missing and also the java.util.Stack<E> concrete implemetation which is not covered on the site, but should help in visualisation:

List Interfaces & ClassesTop

The table below gives a description of each interface and class within the above diagram. Click a link to go to detailed information about a particular interface or class:

List Types and OrderingTop

The table below extrapolates the commented information about ordering from the diagram above into a more readable tabular format:

ArrayListsTop

An ArrayList is a resizable-array, ordered implementation of the List<E> interface that permits all elements including null. ArrayList allows random access to elements and is similar to Vector apart from being unsynchronized.

This type of list is a good choice when you want fast access and iteration but are not doing a lot of insertions and deletions.

ArrayList<E> Method OverviewTop

The table below shows the declarations of all the methods for the ArrayList<E> class implemented from the List<E> interface:

Usage for the the first six methods is shown in the example below. For more information on the other methods in the ArrayList<E> class the following link will take you to the online version of documentation for the JavaTM 2 Platform Standard Edition 5.0 API Specification. Take a look at the documentation for the ArrayList<E> class which you can find by scrolling down the lower left pane and clicking on ArrayList.

ArrayList<E> ExampleTop

Lets write a simple class that creates an ArrayList and uses some of the methods from the ArrayList<E> class:

/*
  Simple class to create an ArrayList and use several methods from the class 
*/
import java.util.*; // Import the java.util package

public class ArrayListClass {

    public static void main (String[] args) {
        List<Object> al = new ArrayList<Object>();
        String s = "hello";
        al.add(s);
        al.add(new Integer(123));
        al.add(s);
        al.add("goodbye");
        al.add(s+s);
        al.add("goodbye");
        System.out.println("array list size = " + al.size());
        // Use enhanced for loop to iterate over the collection
        for (Object o : al) { 
            System.out.println(o);  // Print element
        }        
        al.add(2, new Integer(123));
        al.remove(4);  
        System.out.println("array list size = " + al.size());
        System.out.println("first occurrence of s = " + al.indexOf(s));
        System.out.println("last occurrence of s = " + al.lastIndexOf(s));
        // Use enhanced for loop to iterate over the collection
        for (Object o : al) { 
            System.out.println(o);  // Print element
        }        
    }
}

Save, compile and run the ArrayListClass class in directory   c:\_Collections in the usual way.

The above screenshot shows the results of creating and running our ArrayListClass class and using several of the methods contained within the ArrayList<E> class.

VectorsTop

A Vector is a resizable-array, ordered implementation of the List<E> interface that permits all elements including null. Vector allows random access to elements and is similar to ArrayList apart from being synchronized. In fact Vector is one of the two original collections shipped with Java, the other being Hashtable. Vector was retrofitted to implement List<E> interface, so that it became a part of The Collections Framework when the framework was introduced in version 1.2.

There is no sound reason since the introduction of the ArrayList<E> class to use the Vector<E> class. If you need an ArrayList to be synchronized this can be achieved using methods of the Collections class without all the overheads of using Vector<E> synchronized methods.

Vector<E> Method OverviewTop

The methods for the Vector<E> class are very similar to those used for the ArrayList<E> class apart from being synchrozied so we won't go into them here. If you want to take a look at the Vector<E> class methods the following link will take you to the online version of documentation for the JavaTM 2 Platform Standard Edition 5.0 API Specification. Take a look at the documentation for the Vector<E> class which you can find by scrolling down the lower left pane and clicking on Vector.

Vector<E> ExampleTop

Lets write a simple class that creates a Vector and uses some of the methods from the Vector<E> class:

/*
  Simple class to create an Vector and use several methods from the class 
*/
import java.util.*; // Import the java.util package

public class VectorClass {

    public static void main (String[] args) {
        List<Object> vec = new Vector<Object>();
        String s = "hello";
        vec.add(s);
        vec.add(new Integer(123));
        vec.add(s);
        vec.add("goodbye");
        vec.add(s+s);
        vec.add("goodbye");
        System.out.println("vector size = " + vec.size());
        // Use enhanced for loop to iterate over the collection
        for (Object o : vec) { 
            System.out.println(o);  // Print element
        }        
        vec.add(2, new Integer(123));
        vec.remove(4);  
        System.out.println("vector size = " + vec.size());
        System.out.println("first occurrence of s = " + vec.indexOf(s));
        System.out.println("last occurrence of s = " + vec.lastIndexOf(s));
        // Use enhanced for loop to iterate over the collection
        for (Object o : vec) { 
            System.out.println(o);  // Print element
        }        
    }
}

Save, compile and run the VectorClass class in directory   c:\_Collections in the usual way.

The above screenshot shows the results of creating and running our VectorClass class and using several of the methods contained within the Vector<E> class.

LinkedListsTop

A LinkedList is an ordered implementation of the List<E> interface that is accessed sequentialy using a doubly-linked list running through all of its elements. Because of this, the sequential access and the fact that the LinkedList<E> class also implements the Queue<E> interface, there are methods unique to this type of List.

This type of list is a good choice when you are doing a lot of insertions and deletions and because of the implementation of the Queue<E> interface is also a good candidate for stacks and queues.

LinkedList<E> Method OverviewTop

The table below shows the declarations of all the methods for the LinkedList<E> class implemented from the List<E> and Queue<E> interfaces:

Usage for the the first three methods is shown in the example below. For more information on the other methods in the LinkedList<E> class the following link will take you to the online version of documentation for the JavaTM 2 Platform Standard Edition 5.0 API Specification. Take a look at the documentation for the LinkedList<E> class which you can find by scrolling down the lower left pane and clicking on LinkedList.

LinkedList<E> ExampleTop

Lets write a simple class that creates a LinkedList and uses some of the methods from the LinkedList<E> class:

/*
  Simple class to create a LinkedList and use several methods fron from the class 
*/
import java.util.*; // Import the java.util package

public class LinkedListClass {

    public static void main (String[] args) {
        List<Object> ll = new LinkedList<Object>();
        String s = "hello";
        ll.add(s);
        ll.add(new Integer(123));
        ll.add(s);
        ll.add("goodbye");
        ll.add(s+s);
        System.out.println("linked list size = " + ll.size());
        System.out.println("linked list contains: " + ll);
        ll.add(3, new Integer(123));
        System.out.println("linked list size = " + ll.size()); 
        System.out.println("linked list contains: " + ll);
    }
}

Save, compile and run the LinkedListClass class in directory   c:\_Collections in the usual way.

The above screenshot shows the results of creating and running our LinkedListClass class.

Lesson 4 Complete

In this lesson we looked at Lists.

What's Next?

In our final lesson on the different collection types within the Collection hierarchy we look at the PriorityQueue<E> concrete implementation of the Queue<E> interface.

Homepage Top