Cours 7

I. Collections I.1 Intérêt I.1.a) Vision unifiée de plusieurs structures de données et algorithmes => plusieurs fonctionnements plus faciles à apprendre
I.1.b) Moins à programmer (implémentations totales ou partielles) => pouvoir se concentrer sur le haut niveau
I.1.c) Augmente les performances et la qualité car le JDK est super optimisé et il reste plus de temps pour améliorer ses propres méthodes.
I.1.d) Interopérabilité avec plusieurs API non liées aux collections
I.1.e) Encourage la réutilisation
I.2 Contenu du framework = Interfaces + Implémentations + Algorithmes (voir les détails à partir du I.7 ci-dessous)
  Cours complet (en PDF) sur les collections
I.3 Type des éléments (jamais de type primitif) et généricité simple   Classe<Type> I.3.a) 1 type (celui des éléments)
I.3.b) obligatoire, y compris dans le constructeur
I.3.c) types primitifs interdits (mais voir solution au I.4)
I.3.d) la collection est générique, le type est le paramètre générique → concept de généricité
I.4 Classes enveloppes (une pour chacun des 8 types primitifs)
I.4.a) à chaque type primitif correspond une classe enveloppe
I.4.b) boîte autour d'un unique attribut du type primitif correspondant + méthodes
I.4.c) normalement même nom avec majuscule initiale :
- règle : Byte, Short, Long, Float, Double, Boolean
- exceptions quand le type primitif est abrégé : Integer, Character
I.4.d) package java.lang.
I.4.e) conversions : - (type) : non !
- primitif→enveloppe : constructeur. Exemple : int p1 = 12; Integer o2 = new Integer( p1 );
- enveloppe→primitif : méthode. Exemple : int p3 = o2.intValue(); (généralement : xxxValue() avec xxx = type primitif)
- String→enveloppe : constructeur. Exemple : Integer o4 = new Integer( "12" );
- enveloppe→String : o4.toString()
I.4.f) exemples d'autres méthodes :
- int ← Integer.parseInt( String ) (généralement : xxx ← Enveloppe.parseXxx( String ) avec xxx = type primitif)
- boolean ← Character .isDigit() .isLetter() .isLower() .toLowerCase() .isUpper() ...
I.5 Auto-(un)boxing
C'est la facilité que propose Java pour convertir automatiquement une valeur d'un type primitif en objet du type enveloppe correspondant, et vice-versa. Exemple : 1. ArrayList<Double> coll = new ArrayList<Double>();
2. double s = 0.0;
3. coll.add( 3.14 ); // auto-boxing : double → Double
4. double element = coll.get(0); // auto-unboxing : Double → double
5.   s = s + element;
Commentaires :
- Ligne 1 : ArrayList<double> serait interdit (les collections ne contiennent que des objets)
- Ligne 3 : sans auto-boxing, il faudrait écrire coll.add( new Double( 3.14 ) );
- Ligne 4 : sans auto-unboxing, on aurait du écrire Double element = coll.get( 0 ), MAIS
- Ligne 5 : il aurait aussi fallu écrire s = s + element.doubleValue()
I.6 Parcours (for each ou itérateur) si Iterable I.6.a) Pseudo-langage
POUR CHAQUE element DANS collection FAIRE
  instructions (pouvant utiliser element)
FIN POUR CHAQUE
I.6.b) Java
for ( typeElement element : collection ) {
  instructions
} // for:
I.6.c) Commentaires
- uniquement pour parcours simple (du début à la fin, à partir du premier)
- typeElement peut être un type objet ou un type primitif (si collection contient des éléments du type enveloppe correspondant).
- element est un simple nom de variable.
- le type des éléments de collection doit être typeElement (sauf dans le cas où typeElement est un type primitif, voir ci-dessus).
- Sans cette nouvelle boucle for, il faudrait utiliser un itérateur (voir chapitre suivant).
I.7 Les interfaces
I.8 Les implémentations incomplètes
I.9 Les implémentations complètes
I.10 Les algorithmes
I.11 Les maps
II. Itérateurs II.1 Iterator
    a)
    public interface Iterator<E>
    {
        boolean hasNext();
        E next();
        void remove(); //optional
    }
    b) Exemple :
    Iterator it = collection.iterator();
    while ( it.hasNext() ) {
      typeElement element = it.next();
      instructions avec element
    }   
c) obligatoire si : - <= JDK 1.4.2
- parcours non simple (à l'envers ou bien à partir du Xème)
- parcours de 2 collections en //
- modification de la collection (notamment remove() => utiliser it.remove();)
II.2 ListIterator
    public interface ListIterator<E> extends Iterator<E>
    {
        boolean hasPrevious();
        E previous();
        int nextIndex();
        int previousIndex();
        void set(E e); //optional
        void add(E e); //optional
    }   
II.3 Scanner : lire/saisir (et décoder) des valeurs II.3.a) new Scanner( System.in )
II.3.b) new Scanner( oneString )
II.3.c) new Scanner( oneFile ) (voir chapitre IV ci-dessous)
II.3.d) méthodes (next, nextPrimitiveType, nextLine, hasNext, hasNextPrimitiveType, hasNextLine, useDelimiter, useRadix, useLocale, reset, close)
- - - - - - - - - - - - - - - - - - - - - - - - - - non traité
III. Généricité III.1 Création de méthodes génériques
III.2 Création de classes génériques
III.3 Wildcards; bornes. (Généricité complexe)

- - - - - - - - - - - - - - - - - - - - - - - - - - hors programme
IV. Fichiers de texte

(ne lire que les lignes noires et les lignes bleues)
V. Applettes V.1 Concept
V.2 Classe (java.awt.Applet, javax.swing.JApplet)
V.3 Fichier html (navigateur, appletviewer, exemple)
V.4 Méthodes (init, start, stop, destroy)
V.5 Exemple
- - - - - - - - - - - - - - - - - - - - - - - - - -

Lire le poly :
tout jusqu'à la section 2.4.2, sections 2.5, 3.1 à 3.3, 3.6, 4, 5.1, 5.2.0, 5.2.1, 5.2.5, 5.3, 6, 7.1, 7.2, 8.1, 8.2, 8.3 à 8.3.2.1, 8.3.2.3, 9, 10, 13.3, et annexes 6 & 7


--> Dernière mise à jour :