Développons en Java

13/07/2003

• Vector
• Stack
• Hashtable
• Bitset

• Collection : interface qui est implementée par la plupart des objets qui gèrent des collections
• Map : interface qui définie des méthodes pour des objets qui gèrent des collections sous la forme clé/valeur
• Set : interface pour des objets qui n'autorisent pas la gestion des doublons dans l'ensemble
• List : interface pour des objets qui autorisent la gestion des doublons et un accès direct à un élément
• SortedSet : interface qui étend l'interface Set et permet d'ordonner l'ensemble
• SortedMap : interface qui étend l'interface Map et permet d'ordonner l'ensemble

• HashSet : HashTable qui implémente l'interface Set
• TreeSet : arbre qui implémente l'interface SortedSet
• ArrayList : tableau dynamique qui implémente l'interface List
• LinkedList : liste doublement chaînée (parcours de la liste dans les deux sens) qui implémente l'interface List
• HashMap : HashTable qui implémente l'interface Map
• TreeMap : arbre qui implémente l'interface SortedMap

• Iterator : interface pour le parcours des collections
• ListIterator : interface pour le parcours des listes dans les deux sens et modifier les éléments lors de ce parcours
• Comparable : interface pour définir un ordre de tri naturel pour un objet
• Comparator : interface pour définir un ordre de tri quelconque

• Vector : tableau à taille variable qui implémente maintenant l'interface List
• HashTable : table de hashage qui implémente maintenant l'interface Map

Iterator iterator = collection.Iterator();
while (iterator.hasNext()) {
            System.out.println("objet = "+iterator.next());
}

     Iterator iterator = collection.Iterator();
      if (iterator.hasNext()) {
            iterator.next();
            itérator.remove();
      }
      

LinkedList listeChainee = new LinkedList();
      Iterator iterator = listeChainee.Iterator();
      listeChainee.add("element 1");
      listeChainee.add("element 2");
      listeChainee.add("element 3");
      while (iterator.hasNext()) {
            System.out.println("objet = "+iterator.next());
      }

• les éléments d'un objet HashSet ne sont pas triés : l'insertion d'un nouvel élément est rapide
• les éléments d'un objet TreeSet sont triés : l'insertion d'un nouvel éléments est plus long

• les éléments contenus dans l'ensemble implémentent l'interface Comparable pour définir leur ordre naturel
• il faut fournir au constructeur de l'ensemble un objet Comparator qui définit l'ordre de tri à utiliser

import java.util.*;
public class TestHashSet {
  public static void main(String args[]) {
    Set set = new HashSet();
    set.add("CCCCC");
    set.add("BBBBB");
    set.add("DDDDD");
    set.add("BBBBB");
    set.add("AAAAA");
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {System.out.println(iterator.next());}
  }
}

AAAAA
DDDDD
BBBBB
CCCCC

import java.util.*;
public class TestTreeSet {
  public static void main(String args[]) {
    Set set = new TreeSet();
    set.add("CCCCC");
    set.add("BBBBB");
    set.add("DDDDD");
    set.add("BBBBB");
    set.add("AAAAA");
    Iterator iterator = set.iterator();
    while (iterator.hasNext()) {System.out.println(iterator.next());}
  }
}

AAAAA
BBBBB
CCCCC
DDDDD

• HashMap qui stocke les éléments dans une table de hashage
• TreeMap qui stocke les éléments dans un arbre

• les clés contenues dans la collection implémentent l'interface Comparable pour définir leur ordre naturel
• il faut fournir au constructeur de la collection un objet Comparator qui définit l'ordre de tri à utiliser

import java.util.*;
public class TestHashtable {
  public static void main(String[] args) {
    Hashtable  htable = new Hashtable();
    htable.put(new Integer(3), "données 3");
    htable.put(new Integer(1), "données 1");
    htable.put(new Integer(2), "données 2");
    System.out.println(htable.get(new Integer(2)));
  }
}

données 2

import java.util.*;
public class TestTreeMap {
  public static void main(String[] args) {
    TreeMap arbre = new TreeMap();
    arbre.put(new Integer(3), "données 3");
    arbre.put(new Integer(1), "données 1");
    arbre.put(new Integer(2), "données 2");
    Set cles = arbre.keySet();
    Iterator iterator = cles.iterator();
    while (iterator.hasNext()) {
      System.out.println(arbre.get(iterator.next()));
    }
  }
}

données 1
données 2
données 3

• elle est apparue dans le JDK 1.2
• elle n'est pas synchronisée
• elle autorise les objets null comme clé ou valeur

• Comparable
• Comparator

• une valeur entière négative si l'objet courant est inférieur à l'objet fourni
• une valeur entière positive si l'objet courant est supérieur à l'objet fourni
• une valeur nulle si l'objet courant est égal à l'objet fourni

• une valeur entière négative si le premier objet est inférieur au second
• une valeur entière positive si le premier objet est supérieur au second
• une valeur nulle si les deux objets sont égaux

• XXX synchronizedXXX(XXX) pour obtenir une version multi-thread des objets implémentant l'interface XXX
• XXX unmodifiableXXX(XXX) pour obtenir une version non modifiable des objets implémentant l'interface XXX

import java.util.*;
public class TestUnmodifiable{
    public static void main(String args[])
    {
      List list = new LinkedList();
      list.add("1");
      list.add("2");
      list = Collections.unmodifiableList(list);
      list.add("3");
    }
}

C:\>java TestUnmodifiable
Exception in thread "main" java.lang.UnsupportedOperationException
        at java.util.Collections$UnmodifiableCollection.add(Unknown Source)
        at TestUnmodifiable.main(TestUnmodifiable.java:13)

import java.util.*;
public class TestSynchronized{
    public static void main(String args[])
    {
      List maList = new LinkedList();
      maList.add("1");
      maList.add("2");
      maList.add("3");
      maList = Collections.synchronizedList(maList);
      synchronized(maList) {
          Iterator i = maList.iterator();
          while (i.hasNext())
               System.out.println(i.next());
          }
     }
}