précédent | suivant | table des matières

AbstractCollection

Cette classe abstraite fournit une implémentation minimale de l’interface Collection en utilisant essentiellement les itérateurs.

public abstract class AbstractCollection<E> implements Collection<E> {
  ...
}

1 Le constructeur par défaut : 

protected AbstractCollection(){

}

2 Les méthodes qui sont abstraites, ou non supportées :

   public abstract Iterator<E> iterator();

   public abstract int size();

La méthode optionnelle add est définie dans la classe AbstractCollection et lèvent une exception UnsupportedOperationException : 

public boolean add(E o) {
   throw new UnsupportedOperationException();
}
 

3 Les méthodes définies :

La méthode isEmpty() peut être définie en utilisant la méthode size() : 

public boolean isEmpty() {
    return  size() == 0;
}

La méthode contains(Object o) retourne true si l’objet o appartient à la collection et false sinon : 

   public boolean contains(Object o){
      Iterator<E> e = iterator(); 
      if(o==null) { 
          while(e.hasNext())
                if (e.next()==null) return true;
      }else {
          while (e.hasNext())
               if (o.equals(e.next())) return true;
      }
      return false;
   }

Les deux méthodes suivantes convertissent un vecteur en un tableau d’Object : 

    public Object[] toArray() { 
      Object[] result = newObject[size()]; 
      Iterator<E> e = iterator(); 
      for (int i=0; e.hasNext(); i++) 
         result[i] = e.next();
      return result;
   }

   public Object[] toArray() { 
      Object[] result = new Object[size()]; 
      int i = 0; 
      for (E x : this)
         result[i++] = x;
      return result; 
   } 

La méthode suivante, copie tous les éléments du vecteur dans le tableau t et retourne ce tableau si celui-ci est assez grand, sinon elle copie les éléments dans un tableau qui est créé et le retourne.

• Si le tableau t est plus grand que le nombre d’éléments du vecteur, alors l’élément qui suit le dernier copié est affecté de la valeur null.
• Le type du tableau retourné est le même que le type du tableau t. Une exception ArrayStoreException est levée si le vecteur contient un élément qui n’est pas de la classe (ou d’une classe dérivée ) des éléments du tableau t.

   public <T>  T[] toArray(T[]  a ) {
       if (a.length < size())
           a = (T[])java.lang.reflect.Array.newInstance(
              a.getClass().getComponentType(), size());
       Iterator<E> it = iterator();
       for (int i = 0; i < size(); i++)
           a[i] = it.next();
       if (a.length > size())
           a[size()] = null;
       return a;
   }

Les méthodes  ayant en paramètre une collection  sont définies de la façon suivante: 

public booleancontainsAll(Collection<?> c) {
      Iterator<E> e = c.iterator();
      while (e.hasNext())
      if(!contains(e.next()))
          return false;
      return true;
}

public   boolean containsAll(Collection<?> c) {
      for(E x : c) if(!contains(x)) return   false; 
      return true;
}

public boolean addAll(Collection<?  extends E> c ){
      boolean modifie = false;
      Iterator<E> e = c.iterator(); 
      while (e.hasNext()) {
         if(add(e.next())) modifie = true;
      }
      return modifie;
}

public boolean addAll(Collection<? extends E> c){ 
      boolean modifie = false
      for(E e : c)
         if(add(e)) modifie = true;
      return modifie;
}

public boolean removeAll(Collection<?> c) {
   boolean modifie = false;
   Iterator<E> e = iterator();
   while (e.hasNext()) {
        if(c.contains(e.next())){
           e.remove();
           modifie = true;
        }
   }
   return modifie;
}

public boolean retainAll(Collection<?> c) {
   boolean modifie = false;
   Iterator<E> e = iterator();
   while (e.hasNext()) {
      if(!c.contains(e.next())) {
         e.remove();
         modifie = true;
      }
   }
   return modifie;
}

Les méthodes suivantes sont optionnelles parce que la méthode remove de Iterator est optionnelle, elles peuvent être définies en utilisant remove : 

public void clear() {
   Iterator<E> e = iterator(); 
   while (e.hasNext()) {
       e.next();
       e.remove();
   }
}

public boolean remove(Object o) {
   Iterator<E> e = iterator(); 
   if (o==null) {
      while (e.hasNext()) {
           if (e.next()==null){
               e.remove();
               return true;
           }
      }
   }else{
        while(e.hasNext()) {
          if(o.equals(e.next())) {
             e.remove();
             return true;
          }
        }
   }
   return false;
}

La méthode toString peut aussi être définie dans la classe AbstractCollection : 

public String toString() {
   StringBuffer buf = new StringBuffer();
   Iterator<E> e = iterator();
   buf.append("[");
   if( nbElements!=0 ){
      buf.append(String.valueOf(e.next()));
      for (int i = 1; i < size(); i++) 
         buf.append(","+String.valueOf(e.next()));
   }
   buf.append("]");
   return buf.toString();
}

haut de la page