Les listes comme les tableaux, vecteurs ou autres objets plus sophistiqués sont très couramment utilisées et doivent être parfaitement maîtrisées pour tirer partie du langage.
Un tableau est un objet ayant un nombre d'éléments fixe et pouvant contenir des objets ou des types primitifs. A la différence de certains langages, un tableau est lui-même un objet.
Un tableau peut contenir des primitifs tous du même type : {1,2,3} ou {'a','b','c'}.
Un tableau peut également contenir des objets de mêmes types : {new Integer(1),new Vehicule(),new Voiture()} est un tableau d'Object et { new Integer(1),new Integer(2),new Integer(3)} est un tableau d'Integer.
Tableau de 5 entiers primitifs :
int[] monTableau=new int[5];
ou
int monTableau[]=new int[5];
La première
notation est de loin la meilleure car de cette façon, nous
visualisons bien que monTableau est de type tableau d'entiers
primitifs. Dans la seconde notation, les crochets sont mis à
la fin de la référence pour assurer une continuité
avec les normes du C mais il faut absolument éviter de
l'utiliser.
Un tableau Java peut contenir des primitifs ( tel un int ) ou des objets ( tel l'objet Voiture ).
Attention! Il faut bien comprendre qu'un tableau en Java est un objet à part entière. Ainsi, un tableau possède la propriété length:
monTableau.length vaut 5.
Autre conséquence:
Object[]
monTableau; ne réserve pas d'espace mémoire mais
spécifie simplement que la variable monTableau est un
tableau. Faire monTableau[0]=1; lèvera une exception.
La notation d'accès au contenu d'un tableau est celle du C:
monTableau[2]=3;
Les tableaux peuvent être de
n'importe quelle dimension, par exemple, il est possible de créer
le tableau suivant:
int[][][]
monTableau=new int[3][4][5];
Il est possible d'initialiser un tableau déjà rempli par la syntaxe:
int[] iMonTableau={1,2,3};
int[][]
iMonTableau2={{1,2},{2,3},{4,5}};
Object[]
oMonTableau={new Object(),new Object()};
Dans cette syntaxe, nous ne précisons pas le nombre d'éléments et nous n'instancions pas le tableau car le compilateur va le faire à notre place. C'est simplement un confort du langage qui évite d'avoir à faire:
int iMonTableau[]=new int[5];
iMonTableau[0]=1;
iMonTableau[1]=2;
iMonTableau[2]=3;
...
Mais il y a
bien instanciation du tableau: un tableau est un objet.
Une façon rapide de copier le contenu d'un tableau à un autre est d'utiliser la méthode statique arraycopy de la classe System:
System.arraycopy(Object,int,Object,int,int)
System.arraycopy([Tableau
d'origine],[index de la première donnée à
copier],[tableau de destination],[index de la première donnée
copiée],[nombre d'éléments à copier]);
Lorsque l'on crée un tableau, il faut spécifier sa taille qui est fixe. Java fourni un objet très utilisé: le vecteur ( classe java.util.Vector ). L'utilisation d'un vecteur plutôt qu'un tableau est souvent avantageux lorsque la taille finale du tableau n'est pas connue à l'avance. Un vecteur est un tableau dynamique. La première cellule d'un vecteur est à l'index zéro.
|
Action |
Syntaxe |
|
Création d'un vecteur vMonVecteur
|
Vector vMonVecteur = new Vector(); |
|
Insertion d'un objet o
|
addElement(Object o);
|
|
Suppression d'un élément à la position i |
removeElementAt(int i); |
|
Obtention du i ème élément
|
Object elementAt(int i); |
|
Obtention du no de la ligne contenant l'objet o |
int indexOf(Object o); |
|
Nombre d'éléments dans le vecteur
|
int size();
|
|
Parcours d'un vecteur: Nous utilisons un objet Enumeration. Cf. 3.4- Les Enumérations |
Enumeration
eEnum=vMonVecteur.elements();
while(eEnum.hasMoreElements(){
|
|
Remplacement de l'objet à l'index i par l'objet o |
setElementAt(Object o, int i) |
Remarque importante:
La méthode getElementAt(int) renvoie un objet qu'il faut
caster.
Exemple:
Integer
i1=(Integer)vMonVecteur.elementAt(0);
Une autre propriété intéressante des listes est la possibilité d'accéder aux informations par clé comme dans les dictionnaires. Ce type de liste est une sorte de tableau à deux colonnes et n lignes dont la première colonne est la clé de recherche la seconde l'information associée. Remarquons que les dictionnaires - tout comme les vecteurs - sont de taille dynamique. Un dictionnaire est une collection qui associe un objet à une clé.
|
Action |
Syntaxe |
|
Création du dictionnaire hMonDico |
Hashtable hMonDico=new Hashtable();
|
|
Insertion d'une entrée avec o1 comme clé et o2 comme valeur |
put(Object o1,Object o2) h.put("Objet","Un objet est une instance de classe"); Un dictionnaire peut associer tout type d'objet à tout autre type d'objet |
|
Obtention de la valeur associée à la clé o |
Object get(Object o) System.out.println(hMonDico.get("Objet")); affichera "Un objet est une instance de classe" |
|
Taille du dictionnaire |
int size() hMonDico.size(); |
|
Effacement de l'entrée correspondant à la clé o |
remove(Object o) hMonDico.remove("Objet"); |
Remarque: S'il on insère deux éléments dans la hashtable avec la même clé, le second élément écrase simplement le premier.
Les énumérations sont des interfaces du package java.util qui permettent de parcourir rapidement les listes comme les vecteurs ou les dictionnaires. Elles sont plus rapides à l'exécution et plus pratique que les méthodes elementAt(int) de Vector par exemple.
Pour obtenir l'énumération sur un vecteur ou un dictionnaire ( entre autres ), il suffit d'appeler la méthode elements() de cette liste.
La classe Enumeration ne possède que deux méthodes:
Object nextElement() qui renvoie l'objet suivant dans l'énumération. ( Attention aux problèmes de cast ! ).
boolean hasMoreElements() qui renvoie true si la fin de l'énumération est atteinte.
Après le premier appel à la méthode nextElement, l'énumération pointe sur le premier élément de la liste.
Pour repositionner l'énumération au premier élément, il faut refaire un appel à la méthode elements() de la liste qui renvoie une nouvelle énumération initialisée.
Attention aux cas imprévus ou indéterminés: si vous ajoutez ou effacez des éléments dans les listes, il faut récupérer une nouvelle énumération de la liste mise à jour.
1- Dans un programme de test, faire :
int[]
iMonTableau;
iMonTableau[0]=0;
Que se passe-t-il? Pourquoi?
2- Déclarer et instancier un tableau d'entier primitifs à 3 dimensions de 2, 3 et 4 éléments suivant chaque dimension. Combien ce tableau contient d'éléments ? Ce tableau est-t-il un objet? contient-t-il des objets ?
3- Déclarer un tableau d'objets Integer à deux dimensions et l'initialiser par la "syntaxe par accolades". Pourquoi n'a-t-on pas instancié le tableau ?
4- Déclarer et instancier un tableau de deux objets Integer. Instancier le premier objet Integer puis l'afficher. Afficher le second entier. Que se passe-t-il ? pourquoi ?
5- Créer un tableau de flottants primitifs à deux dimensions avec pour la première ligne 3 éléments, la seconde 4 éléments et la troisième 5 éléments.
6- Instancier un tableau quelconque et l'afficher ( la tableau lui-même, et non ses éléments ). Que voyez vous ? Que cela signifie-t-il ?
1- Créer un vecteur contenant des objets de types Object,Integer,Float puis affichez sa taille.
2- Ajoutez un objet de votre choix en plus de ceux déjà existants.
3- Supprimez l'élément à l'index 3 dans ce vecteur ( le 4éme élément ).
4- Affichez le type de tous les objets de ce vecteur en utilisant les énumérations.
5- Modifiez le programme pour que lorsqu'il trouve un objet de type Integer, il le supprime et qu'il ajoute un objet de type Float.
6- Vérification finale : Affichez de nouveau les types des éléments du vecteur pour vérifier le travail de la question 5.
1- Créer une liste téléphonique en utilisant un dictionnaire contenant quelques lignes puis afficher sa taille.
2- Donnez le no de téléphone d'une des personnes stockées dans le dictionnaire
3- Supprimez l'entrée concernant une personne donnée.