Les collections dans l'API Java

Le tutoriel

http://java.sun.com/docs/books/tutorial/collections/index.html

Architecture

Interfaces des collections de java.util

public interface Collection {
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element);     // Optional
boolean remove(Object element);  // Optional
Iterator iterator();

boolean containsAll(Collection c);
boolean addAll(Collection c);    // Optional
boolean removeAll(Collection c); // Optional
boolean retainAll(Collection c); // Optional
void clear();                    // Optional

Object[] toArray();
Object[] toArray(Object a[]);

}

public interface Iterator {

boolean hasNext();
Object next();
void remove();                   // Optional
}

public interface Set {

int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element);     // Optional
boolean remove(Object element);  // Optional
Iterator iterator();

boolean containsAll(Collection c);
boolean addAll(Collection c);    // Optional
boolean removeAll(Collection c); // Optional
boolean retainAll(Collection c); // Optional
void clear();                    // Optional

Object[] toArray();
Object[] toArray(Object a[]);

}

public interface List extends Collection {

Object get(int index);
Object set(int index, Object element);            // Optional
void add(int index, Object element);              // Optional
Object remove(int index);                         // Optional
abstract boolean addAll(int index, Collection c); // Optional

int indexOf(Object o);
int lastIndexOf(Object o);

ListIterator listIterator();
ListIterator listIterator(int index);

List subList(int from, int to);

}

public interface ListIterator extends Iterator {

boolean hasNext();
Object next();
boolean hasPrevious();
Object previous();

int nextIndex();
int previousIndex();

void remove();          // Optional
void set(Object o);     // Optional
void add(Object o);     // Optional

}

public interface Map {

Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();

void putAll(Map t);
void clear();

public Set keySet();
public Collection values();
public Set entrySet();

public interface Entry {

Object getKey();
Object getValue();
Object setValue(Object value);
}
}

public interface Comparable {

public int compareTo(Object o);
}

public interface Comparator {

int compare(Object o1, Object o2);
}

public interface SortedSet extends Set {

SortedSet subSet(Object fromElement, Object toElement);
SortedSet headSet(Object toElement);
SortedSet tailSet(Object fromElement);

Object first();
Object last();

Comparator comparator();

}

public interface SortedMap extends Map {

Comparator comparator();

SortedMap subMap(Object fromKey, Object toKey);
SortedMap headMap(Object toKey);
SortedMap tailMap(Object fromKey);

Object first();
Object last();

}

Implémentations

  Implementations
Table de hachage
Vecteur extensible Arbre équilibré Liste chaînée
Interfaces
Collection
HashSet
ArrayList
TreeSet
LinkedList
Set
HashSet
  TreeSet  
List
 
ArrayList
 
LinkedList
Map
HashMap
 
TreeMap
 
SortedSet
 
 
 TreeSet
 
SortedMap
 
 
 TreeMap
 

Classes abstraites

La classe Collections

public class Collections {
public static final Set EMPTY_SET;
public static final List EMPTY_LIST;
public static final Map EMPTY_MAP;

public static void sort(List list);
public static void sort(List list, Comparator c);
public static int binarySearch(List list, Object key);
public static int binarySearch(List list, Object key, Comparator c);
public static void reverse(List l);
public static void shuffle(List list);
public static void shuffle(List list, Random rnd);
public static void fill(List list, Object o);
public static void copy (List dest, List src);
public static Object min(Collection coll);
public static Object min(Collection coll, Comparator comp);
public static Object max(Collection coll);
public static Object max(Collection coll, Comparator comp);

public static Collection unmodifiableCollection(Collection c);
public static Set unmodifiableSet(Set s);
public static SortedSet unmodifiableSortedSet(SortedSet s);
public static List unmodifiableList(List list);
public static Map unmodifiableMap(Map m);
public static SortedMap unmodifiableSortedMap(SortedMap m);

public static Collection synchronizedCollection(Collection c);
public static Set synchronizedSet(Set s);
public static SortedSet synchronizedSortedSet(SortedSet s);
public static List synchronizedList(List list);
public static Map synchronizedMap(Map m);
public static SortedMap synchronizedSortedMap(SortedMap m);

public static Set singleton(Object o);
public static List singletonList(Object o);
public static Map singletonMap(Object key, Object value);

public static List nCopies(int n, Object o);

public static Comparator reverseOrder();

public static Enumeration enumeration(final Collection c);

}