Question

An ArrayList, a List and a Collection in Java behaves almost in the same way and they have many methods in common. If such is a case then, what are the major differences among them? The following simple code snippet demonstrates it.

package collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

final public class Main
{
    public static void main(String[] args) 
    {
        Collection<String> collection=new ArrayList<String>();
        List<String>list=new ArrayList<String>();
        ArrayList<String>arrayList=new ArrayList<String>();        

        collection.add("A");
        collection.add("B");

        list.add("A");
        list.add("B");

        arrayList.add("A");
        arrayList.add("B");

        Iterator<String>collectionIterator=collection.iterator();
        Iterator<String>listIterator=list.iterator();
        Iterator<String>arrayListIterator=arrayList.iterator();

        while(collectionIterator.hasNext())
        {
            System.out.println(collectionIterator.next());
        }

        while(listIterator.hasNext())
        {
            System.out.println(listIterator.next());
        }

        while(arrayListIterator.hasNext())
        {
            System.out.println(arrayListIterator.next());
        }
    }
}

---

When and where to use an ArrayList, a Collection and a List? In which specific situations, the differences among them may be remarkable?

Answer 1

A Collection is an interface that defines the highest-level of shared collection behavior, and extends Iterable (which just defines the iterator() method).

A List is an interface that defines the highest-level of shared List behavior.

ArrayList is an implementation of List and in general wouldn’t be used in a declaration unless you need an implementation guarantee (e.g., fast indexed access), but is fine to use as a list value.

Read the docs to see the differences–they’re described in the API. The implementation (ArrayList) will have a type-specific implementation of each method in each interface it implements.

In general, use the least-specific interface that provides what you need. For example, passing Collection instead of List allows a wider selection of implementations. If you need something like indexed access (e.g., List.get(int)), a Collection wouldn’t work.

As with most things, which to use depends entirely upon your needs.