cm05-collectionettypesgeneriques.pdf — April 5, 2005 — 1

(1)

cm05-collectionettypesgeneriques.pdf — April 5, 2005 — 1 as

Architecture des Systèmes d’Information

Programmation

- Collections et Types g´ en´ eriques -

Nicolas Malandain

April 5, 2005

quelques exemples sont issus du Tutoriel Java de SUN

Collections et Types g´en´eriques 1 / 30

as

Architecture des Systèmes d’Information

1

Collections Pr´ esentation Exemples

L’it´ eration for/in Probl` eme

2

Types g´ en´ eriques Pr´ esentation Classes

Joker et Restriction M´ ethodes

3

Algo g´ en´ eriques Pr´ esentation Le tri d’objets Exemples

4

Autoboxing Pr´ esentation

Collections Types génériques Algo génériques Autoboxing Présentation Exemples L’itérationfor/in Problème

Les collections

D´ efinition

Elles permettent de g´ erer des groupes d’objets de mˆ eme type, leur nombre n’est pas forc´ ement connu ` a l’avance.

Collection versus tableau Tableaux :

non redimensionnables

l’insertion n´ ecessite un d´ ecalage les indices doivent ˆ etre des entiers l´ egers en m´ emoire et acc` es en O(1) Collections :

choix de l’impl´ ementation (complexit´ e) et de l’interface structures dynamiques

algorithmes communs plus gourmands en m´ emoire

Hi´ erarchie des collections

hi´ erarchie des interfaces li´ ees aux collection (package java.util)

(2)

L’interface Collection

Description de l’interface

public interface Collection<E>extendsIterable<E> { // Operations de base

int size();

boolean isEmpty();

boolean contains(Object element);

boolean add(E element); // Optional = retourne vrai si la collection a chang´e boolean remove(Object element); // Optional

Iterator<E> iterator();

// Operations de masse (bulk operation) boolean containsAll(Collection<?> c);

boolean addAll(Collection<?extends E> c);// Optional boolean removeAll(Collection<?> c); // Optional boolean retainAll(Collection<?> c); // Optional

voidclear(); // Optional

// Op´erations de conversion vers des tableaux Object[] toArray();

<T>T[] toArray(T[] a);

}

issu du “tutoriel Sun”

Cette interface est commune ` a toute collection et permet ainsi une interop´ erabilit´ e totale.

L’interface Set

Description de l’interface

public interface Set<E>extendsCollection<E> { // Operations de base

int size();

boolean isEmpty();

boolean contains(Object element);

boolean add(E element); // Optional boolean remove(Object element);// Optional Iterator<E> iterator();

// Operations de masse (bulk operation) boolean containsAll(Collection<?> c);

boolean addAll(Collection<?extends E> c);// Optional boolean removeAll(Collection<?> c);// Optional boolean retainAll(Collection<?> c);// Optional

void clear(); // Optional

// Op´erations de conversion vers des tableaux Object[] toArray();

<T>T[] toArray(T[] a);

}

Cette interface est commune ` a toute collection l’impl´ ementant.

L’interface List

Description de l’interface

public interface List<E>extends Collection<E> { // Op´erations de positionnement

E get(intindex);

E set(intindex, E element); // Optional voidadd(intindex, E element); // Optional

E remove(intindex); // Optional

boolean addAll(intindex, Collection<?extendsE> c);// Optional // Op´erations de recherche

int indexOf(Object o);

int lastIndexOf(Object o);

// It´erateur

ListIterator<E> listIterator();

ListIterator<E> listIterator(intindex);

// Intervalles

List<E> subList(intfrom,intto);

}

Cette interface est commune ` a toute collection l’impl´ ementant.

L’interface Map

Description de l’interface

public interface Map<K,V> { // Op´erations de base Object put(K key, V value);

Object get(Object key);

Object remove(Object key);

boolean containsKey(Object key);

boolean containsValue(Object value);

int size();

boolean isEmpty();

// Operations de masse (bulk operation) void putAll(Map<?extendsK,?extends V> t);

void clear();

// Collections public Set<K> keySet();

public Collection<V> values();

public Set<Map.Entry<K,V>> entrySet();

// Interface for entrySet elements public static interface Entry<K,V> {

boolean equals(Object o);

int hashCode();

K getKey();

V getValue();

V setValue(V value);

}

(3)

cm05-collectionettypesgeneriques.pdf — April 5, 2005 — 3

for/in

Le pattern It´ erateur : l’interface Iterator

Principe

Le pattern it´ erateur est utilis´ e afin de parcourir une collection quelque soit son impl´ ementation et quelque soient les ´ el´ ements qu’elle contient.

L’interface d’Iterator

public interface Iterator<E> { booleanhasNext();

E next();

voidremove(); // Optional }

L’interface Enumeration

Il est maintenant d´ econseill´ e d’utiliser cette interface pour it´ erer sur des collections. En effet, pendant une it´ eration, l’int´ egrit´ e de la collection n’est pas assur´ ee si il y a retrait d’un ´ el´ ement.

for/in

Vue globale : Interface/Impl´ ementation

Impl´ementations

Table de haschage Tableau dynamique Arbre équilibré Liste chainée Interfaces

Set HashSet TreeSet

List ArrayList LinkedList

Map HashMap TreeMap

Quelques informations

Classes de collection Java : <Impl´ ementation><Interface>

Java fournit de base 2 impl´ ementations de chaque interface Les classes AbstractSet, AbstractList, . . . fournissent des squelettes facilitant l’impl´ ementation des collections

Utilisation de collections

ExempleCollections.java

packagefr.insarouen.asi.prog.cours5;

importjava.util.*;

public class ExempleCollections { public static voidmain(String[] args) {

ArrayList al=new ArrayList();

al.add(newInteger(101));

System.out.println(al);

// le ListIterator fournit des fcts suppl´ementaires (previous, hasPrevious, ...) for(Object i : al)

System.out.println("-- "+((Integer)i).intValue()/2+" --");

HashSet hs=new HashSet(al);

System.out.println(hs);

for(Iterator i=hs.iterator();i.hasNext();) { String eltCourant=((Integer)i.next()).toString();

if (eltCourant.startsWith("1")) i.remove();

}

System.out.println(hs);

} }

Le for/in

Syntaxe

for( declaration : expression) instruction ou bloc d’instructions

Utilisation

Cette nouvelle boucle, permet :

sur des tableaux d’utiliser les types simples et objets sur les collections d’utiliser uniquement les types objets (cf autoboxing)

Reprise des it´ erations pr´ ec´ edentes

for(Object i : al)

System.out.println("-- "+((Integer)i).intValue()/2+" --");

for(Iterator i=hs.iterator();i.hasNext();) { String eltCourant=((Integer)i.next()).toString();

if (eltCourant.startsWith("1"))

i.remove();// impossible avec le for/in }

(4)

Les collections et Object

Inconv´ enient

Les collections ne manipulent que des Object :

les collections peuvent ˆ etre totalement h´ et´ erog` enes, c’est ` a la charge du d´ eveloppeur de v´ erifier ce qu’il manipule

il est syst´ ematiquement n´ ecessaire de transtyper

⇒ warning (depuis Java 5.0)

⇒ les types g´ en´ eriques (depuis Java 5.0)

Compilation de ExempleCollections.java

Compilation de base

Compiling 1 source file to /home/nicolas/.../classes

Note: /home/nicolas/.../cours5/ExempleCollections.java uses unchecked or unsafe operations.

Note: Recompile with -Xlint:unchecked for details.

Compilation avec -Xlint:unchecked

Compiling 1 source file to /home/nicolas/.../classes /home/nicolas/.../cours5/ExempleCollections.java:19:

warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList al.add(new Integer(101));

/home/nicolas/.../cours5/ExempleCollections.java:20:

warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.ArrayList ...

5 warnings

Collections Types génériques Algo génériques Autoboxing Présentation Classes Joker et Restriction Méthodes

Pr´ esentation

Principe du type g´ en´ erique

Un type g´ en´ erique est un type param` etrable par un type.

Dans la grande majorit´ e des cas, il s’agit de param´ etrer des collections par la d´ eclaration du type qu’elles manipuleront.

Syntaxe

Type<parametre1, ..., parametreN> // o` u parametre est un type

Exemples d’utilisation des types g´ en´ eriques

ExempleCollectionGenerique.java

public static voidmain(String[] args) { List<String> als=newArrayList<String>();

als.add("Porferlavecelle Vladimir");

// als.add(1); // ne compile pas

// als.add(new StringBuilder("Moinlquart El´eonore")); // ne compile pas for(Iterator<String> i=als.iterator();i.hasNext();) {

String s = i.next();

System.out.println("-- "+s+" --");

}

for(String s : als)

System.out.println("-- "+s+" --");

HashMap<Integer,String> hm=new HashMap<Integer,String>();

hm.put(newInteger(120281930),"Menvussa G´erard");

hm.put(newInteger(523519023),"Naimard Jean");

for(Integer entier : hm.keySet()) System.out.print("("+entier+") ");

}

Map<String, List<String>> hml=newHashMap<String, List<String>>();

}

(5)

cm05-collectionettypesgeneriques.pdf — April 5, 2005 — 5 Conversion de types g´ en´ eriques

Attention !!!

La conversion de type ne se fait que sur le type de base et non sur le type param` etre.

Illustration du probl` eme

List<String> lstr = newLinkedList<String>(); //ok List<Object> lobj = lstr; // ne compile pas // sinon on aurait le probl`eme suivant lobj.add(newObject());

String str = lstr.get(0); // assignation d’un Object `a un String

Objectif

Cr´ eer ses propres classes g´ en´ eriques, les types des attributs et m´ ethodes

´ etant param´ etrables.

Syntaxe pour classe g´ en´ erique

class LaClasse<T> {

// Utilisation du type T comme un type ‘‘normal’’

// d´eclaration d’attributs et m´ethodes utilisant le type T }

// il est courant que le type param`etre ne soit que d’une lettre

Exemple

Paire.java

packagefr.insarouen.asi.prog.cours5;

public class Paire<G,D> { private G valeurGauche;

private D valeurDroite;

public Paire(G valeurGauche, D valeurDroite) { this.valeurGauche=valeurGauche;

this.valeurDroite=valeurDroite;

}

public G getValeurGauche() { returnvaleurGauche;

}

public D getValeurDroite() { returnvaleurDroite;

}

public voidsetValeurGauche(G valeur) { valeurGauche = valeur;

}

public voidsetValeurDroite(D valeur) { valeurDroite = valeur;

}

public String toString() {

return"("+getValeurGauche()+","+getValeurDroite()+")";

} }

Le joker : ?

Objectif

Sp´ ecifier que n’importe quel type de param` etre est accept´ e.

Collection<?> est une collection d’inconnus

Exemple

public void afficheCollection(Collection<?> c) { for(Iterator i<?>=c.iterator(); i.hasNext();)

System.out.println(i.next().toString());

// for(Object obj : c) // autre syntaxe // System.out.println(obj);

} }

Remarque

L’utilisation de Collection<Object> est une faute puisque la conversion est sur le type de base et non sur le type param` etre. La classe m` ere de toutes les collections est Collection<?> et non Collection<Object>.

(6)

Manipulation des ?

Le type des objets manipul´ es est inconnu

Collection<?> c = new ArrayList<String>();

c.add(new Object()); // ne compile pas c.add(new String(‘‘tutu’’));// ne compile pas Object obj = c.get(0); // compile

on ne peut donc pas ajouter d’´ el´ ement, puisque le type est inconnu par contre on peut consulter sans probl` eme via Object, puisqu’on est au moins sˆ ur de ce type.

Restriction des types param` etres

Syntaxe

<T extends UneClasse>

Signifie que T est de type UneClasse ou est d´ eriv´ e de UneClasse

PaireNumerique.java

public class PaireNumerique<Gextends Number, Dextends Number>extends Paire<G,D> { public PaireNumerique(G nbg, D nbd) {

super(nbg,nbd);

}

public doublesomme(){

returngetValeurGauche().doubleValue()+getValeurDroite().doubleValue();

} }

Joker et restriction

Syntaxe

<? extends UneClasse>

Signifie n’importe quelle classe du type UneClasse

reprise de Figure.java

public abstract class Figure { ...

public abstract voiddessine(ZoneDessin d);

}

ZoneDessin.java

public class ZoneDessin {

// n’autorise que des collections de Figure (pas d’int´er^et) public voiddessineFigures(Collection<Figure> figures) {

for(Figure f : figures) f.dessine(this);

}

public voiddessine(Collection<?extends Figure> figures) { for(Figure f : figures)

f.dessine(this);

}

TestCollectionFigures.java

public class TestCollectionFigures {

// ne compile pas (on ne sait pas quel type d’objet manipule la liste) // est ce un sous-type, un super type ou un type ‘‘fr`ere’’ de LeRectangle ? // public static void ajouter(Collection<? extends Figure> figures) { // figures.add(new LeRectangle(3,4));

// }

public static voidmain(String[] args) { List<LeCercle> lc =newArrayList<LeCercle>();

lc.add(newLeCercle(4));

ZoneDessin zd =new ZoneDessin();

zd.dessine(lc);

} }

(7)

cm05-collectionettypesgeneriques.pdf — April 5, 2005 — 7 M´ ethode g´ en´ erique

Utilisation & Syntaxe

Les m´ ethodes g´ en´ eriques sont utilis´ ees lorsque des d´ ependances existent entre les types des argumements et/ou le type de retour. Dans le cas contraire (un seul type de param` etre) la simple utilisation du joker suffit.

<T> typeretour methode(param`etres) {

// utilisation du type T comme un type normal // param`etre, variable locale, ...

}

Probl` eme classique (d´ ej` a ´ evoqu´ e pr´ ec´ edemment)

static voidtableauVersCollection(Object[] tab, Collection<?> col) { for(Object o : tab)

c.add(o)// ne compile pas }

static void<T> tableauVersCollection(T[] tab, Collection<T> col) { for(T o : tab)

c.add(o)// compile }

La classe Collections

Description Collections

ne contient que des m´ ethodes de classe manipule des Collection

offre des algorithmes g´ en´ eriques (tri, max, min, copie, remplacement, . . . )

Pr´ esentation du tri d’objets comme exemple de ces m´ ethodes g´ en´ eriques

Collections Types génériques Algo génériques Autoboxing Présentation Le tri d’objets Exemples

La m´ ethode sort

Deux m´ ethodes de tri dans Collections

public static <T extendsComparable<? super T>> void sort(List<T> list) public static <T> void sort(List<T> list, Comparator<? superT> c)

L’interface Comparable

Utilis´ e par la 1

^◦

m´ ethode, les objets ` a comparer doivent l’impl´ ementer

public interface Comparable<T> { public int compareTo(T o);

}

L’interface Comparator

Utilis´ e par la 2

^◦

m´ ethode, pour comparer des objets n’impl´ ementant pas Comparable ou pour d´ efinir un autre syst` eme de comparaison.

public interface Comparator<T> { public int compare(T o1, T o2);

public boolean equals(Object o);

}

Exemple avec l’interface Comparable

Reprise de PaireNumerique.java

public class PaireNumerique<G extends Number, D extends Number>

extends Paire<G,D>

implements Comparable<PaireNumerique<?,?>> {

public PaireNumerique(G nbg, D nbd) { super(nbg,nbd);

}

public int compareTo(PaireNumerique<?,?> pn) {

doubleres=getValeurGauche().doubleValue()-pn.getValeurGauche().doubleValue();

if (res < 0) return -1;

if (res > 0) return 1;

return 0;

}

public double somme(){

return getValeurGauche().doubleValue()+getValeurDroite().doubleValue();

} }

(8)

Ex´ ecution + exemple avec l’interface Comparator

main

PaireNumerique<Double,Integer> pn1 =newPaireNumerique<Double,Integer>(newDouble(0.10),newInteger(3));

PaireNumerique<Integer,Integer> pn2 =newPaireNumerique<Integer,Integer>(newInteger(4),newInteger(3));

PaireNumerique<Float,Integer> pn3 =newPaireNumerique<Float,Integer>(newFloat(20.10),newInteger(3));

List<PaireNumerique<?,?>> l =newArrayList<PaireNumerique<?,?>>();

l.add(pn3);

l.add(pn2);

l.add(pn1);

Collections.sort(l);

for(PaireNumerique pni : l) System.out.println(pni);

Collections.sort(l,newComparator<PaireNumerique<?,?>>() { public intcompare(PaireNumerique<?,?> o1, PaireNumerique<?,?> o2) {

doubleres=o1.getValeurGauche().doubleValue()-o2.getValeurGauche().doubleValue();

if (res < 0) return1;

if (res > 0) return-1;

return0;

} });

for(PaireNumerique pni : l) System.out.println(pni);

Collections Types génériques Algo génériques Autoboxing Présentation

Autoboxing / Unboxing

Principe

“convertir” un type simple dans son type classe et r´ eciproquement

AutoBoxing.java

public class AutoBoxing { static voidmethode(Integer i) {

System.out.println("Integer : "+i);

}

static voidmethode(doubled) { System.out.println("double : "+d);

}

public static voidmain(String[] args) { Integer i1=10;

int i2=i1;

// 10 autoboxing/unboxing for(Integer i3=0; i3<10; i3++)

System.out.println(i3);

// pour compatibilité avec les JDK précédents // => double : 5.0

methode(5);

Integer a256 = 256, b256 = 256;

if (a256 == b256)

System.out.println("Egal");

else

System.out.println("Non egal");

// les Integer de -127 à 127 sont figés // figé = immutable

Integer a120 = 120, b120 = 120;

if (a120 == b120)

System.out.println("Egal");

else

System.out.println("Non egal");

} }