Tutoriel Java Collections Framework

View more Tutorials:

1- Introduction

La collecte est une idée de base du programme et du langage. Une application fonctionne souvent avec la collecte, par exemple le stockage des informations des employés, la collecte des images, etc. Comme d'autres langages, Java supporte aussi les tableaux (array comme une collection de base. Cependant, travailler avec un tableau n'est pas pratique dans de nombreuses situations parce que dans la durée de vie du tableau, l'augmentation des éléments ou l'élimination des éléments est très difficile et on paie cher pour l'efficacité du programme si nous avons l'intension de le faire. 
L'image ci-dessous illustre un tableau :

2- Le premier exemple

Tout d'abord, nous avons un exemple avec  LinkedList, qui est une liste où le nombre d'éléments peut être modifié, non limité comme tableaux.
HelloLinkedList.java
package org.o7planning.tutorial.javacollection.helloworld;

import java.util.LinkedList;

public class HelloLinkedList {

	public static void main(String[] args) {
		// Créer un objet LinkedList.
		LinkedList<String> list = new LinkedList<String>();

		// Ajouter quelques éléments à la liste
		list.add("F");
		list.add("B");
		list.add("D");
		list.add("E");
		list.add("C");

		// Ajouter l'élément à la fin de la liste
		list.addLast("Z");

		// Ajouter l'élément à la première position de la liste.
		list.addFirst("A");

		// Insérer l'élément spécifié en position avec l'index 1.
		list.add(1, "A2");

		// Écrire tous les éléments de la liste:
		System.out.println("Original contents of list: " + list);

		// Supprimer un élément de la liste
		list.remove("F");

		// Supprimer l'élément en position avec index 2
		list.remove(2);

		// Imprimer la liste après que vous avez supprimé 2 éléments.
		System.out.println("Contents of list after deletion: " + list);

		// Supprimer le premier  et le dernier élément  dans la liste.
		list.removeFirst();
		list.removeLast();

		// Imprimer la liste après qu'elle a été supprimée.
		System.out.println("List after deleting first and last: " + list);

		// Retirer l'élément à l'index 2.
		Object val = list.get(2);

		// Définir l'élément à l'index 2.
		list.set(2, (String) val + " Changed");
		System.out.println("List after change: " + list);
	}

}
Les résultats d'exécution de l'exemple :
Un exemple avec  HashMap. C'est un objet contenant des paires de clé et valeur. Par exemple, un répertoire téléphonique, où le numéro de téléphone est la clé alors que l'information des abonnés est la valeur. Les clés ne sont pas les mêmes.
HelloHashMap.java
package org.o7planning.tutorial.javacollection.helloworld;

import java.util.HashMap;

public class HelloHashMap {

	public static void main(String[] args) {

		// Créer un objet HashMap qui stocke les paires des ID d'employés et des salaires.
		// Clé de chaîne: ID d'employé
		// Valeur flottante: Salaire.
		HashMap<String, Float> salaryMap = new HashMap<String, Float>();
	 

		salaryMap.put("E01", 1000f);
		salaryMap.put("E02", 12000f);
		salaryMap.put("E03", 12300f);
		salaryMap.put("E04", 1000f);
		salaryMap.put("E05", 300.5f);
		
		// Obtenir les salaires des employés 'E02'
		Float salary= salaryMap.get("E01");
		System.out.println("Salary of employee E01 = "+ salary);
		
		// Mettre à jour le salaire pour les employés 'E05'
		salaryMap.put("E05", 400f);
		
		System.out.println("Salary of employee E05 = "+ salaryMap.get("E05"));
		 
	}

}
Les résultats 'exécution de l'exemple :

3- Les limites de l'utilisation des tableaux - Un conseil pour résoudre le problème.

3.1- Tableau - un type de l'ensemble de base.

  • Tableau est très basique et familier .
    • stockage du type de référence, type primitif
    • int[] myArray=new int[]{1,4,3};
    • Object[] myArrayObj =new Object[]{"Object",new Integer(100)};
  • Les tableaux ont des tailles et des dimensions fixes.
    • Cela rend difficile l'utilisation d'un tableau
    Les éléments sont disposés et référencés séquentiellement en mémoire.
    • Cela rend difficile la suppression d'un tableau.

3.2- Supprimer l'élément de tableau

Les éléments d'un tableau sont continuellement arrangés dans la mémoire, il est donc difficile de supprimer intentionnellement un élément du tableau car il perdra la suite. Typiquement, une technique consiste à créer un nouveau tableau stockant les objets du tableau précédent et à éliminer les éléments inutiles, mais cela réduit l'efficacité du programme. Une technique similaire est appliquée à l'expansion du tableau, dans laquelle nous créons un nouveau tableau avec une taille plus grande, puis copions les éléments du tableau précédent dans le nouveau tableau.

Évidemment, le tableau n'est pas un bon moyen dans de nombreuses situations d'application.

3.3- Liste chaînée

La liste chaînée est l'un des moyens de gestion des données qui permet de surmonter les faiblesses du tableau. Bien sûr, il y a plusieurs façons de gérer les listes en Java, par exemple ArrayList

Voyons les fonctionnalités de LinkedList :
  • Les éléments de cette liste peuvent être isolés de façon discontinue dans la mémoire..
  • C'est un lien bidirectionnel entre les éléments.
    • Chaque élément de la liste fait référence à l'élément opposé devant lui et à l'élément juste derrière lui.
LinkedList est vraiment un lien bidirectionnel.​​​​​​​
L'élément Link est un objet contenant des données que vous devez gérer. Il comporte deux références à des éléments Link devant et derrière lui.
Comme un groupe de personnes dans la file d'attente, chaque personne doit se souvenir de deux personnes debout juste devant et derrière elle.
Supprimer un élément de LinkedList​​​​​​​
Supprimer un élément de LinkedList est la même chose que d'éliminer une personne qui se trouve dans une file d'attente. Deux personnes à côté de cette personne doivent mettre à jour les informations des personnes qui se trouvent devant et derrière elles.
Ajouter un élément à LinkedList (ajouter à la fin ou au milieu de la liste)
Ainsi, bien que nous ne donnons qu'un exemple d'une liste chaînée, il nous permet également comprendre plus de package java.util.
Remarque : LinkedList est l'une des solutions pour résoudre les limites des tableaux. ArrayList est une façon de gérer la collecte de données. Il peut traiter les faiblesses du tableau, mais la façon dont il gère les données est différente de celle de LinkedList.

4- Vue d'ensemble de Java Collections Framework

Etant conscient des limitations des tableaux de la version 1.0, Java développe la classe java.util.Vector où on peut stocker la liste des objets. Et java.util.Hashtable est une classe stockant des paires key/value (clé/valeur). Ensuite, Java2 platform continue d'introduire des façons d'aborder les collections, appelées Collections Framework (la base des compilations). java.util.Vector, java.util.Hashtable existent toujours et font maintenant partie de cette énorme plate-forme. Ces compilations sont construites sur la base de certaines interfaces du package  java.util. Ils sont divisés en 2 systèmes hiérarchiques dirigés par 2 interfaces java.util.Collection contenant la liste des objets et java.util.Map contenant les paires key/value (clé/valeur).

4.1- Des interfaces dans Java Collections Framework

L'image ci-dessus est une interface importante de Java Collections Framework, nous allons parler du but d'utilisation de ces interfaces et les regrouper par butd'utilisation et usage. Dans le paquet java.util, les classes implémentent une ou plusieurs de ces interfaces. Ainsi, une classe dans java.util peut avoir de nombreuses fonctions différentes. Par exemple java.util.util.HashMap :
** Hashtable **

public class HashMap<K,V> extends AbstractMap<K,V>
                           implements Map<K,V>, Cloneable, Serializable
** Vector **
public class Vector<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, Serializable

4.2- Deux hiérarchies dirigées par 2 interfaces Collection et Map - Méthodes de stockage des données

  • Le groupe Collection stocke des objets
    •  il y a trois sous branches dans le groupe Collection: Queue, List et Set .
    • Les éléments peuvent être similaires ou non, selon leur branche. (Plus de détails sont discutés plus loin).
  • Le groupe Map stocke de couples key/value ( clé/valeur)
    • Les clés de la Map ne sont pas autorisées de la même manière.
    • Si nous connaissons la clé, nous pouvons extraire la valeur équivalente à sa clé dans Map.
Le groupe Collection stocke les données qui sont les types de référence alors que le groupe  Map stocke les paires  key/value (clé/ valeur) .
Collection<String> c=new ArrayList<String>();
// Ajouter l'élément à la compilation.
c.add("One");


Map<Integer,String> m=new LinkedHashMap<Integer,String>();
Integer key=new Integer(123);
String value="One two three";

// Ajouter une paire de 'key/value' à Map m.
// Si 'key' existe déjà, 'value' sera remplacée par une nouvelle valeur.
m.put(key,value);

// Imprimer la valeur correspondant à 'key' (clé).
System.out.println(m.get(new Integer(123));

4.3- Des interfaces Iterator et interface RandomAccess - Méthodes d'accès des données

  • java.util.Iterator
    •  Est un itérateur pour récupérer des données, en visitant à son tour de cet élément à un autre élément.
  • java.util.RandomAccess
    • Procédé d'accès aléatoire, par exemple pour positionner des éléments et récupérer cet élément dans l'ensemble
    • Par exemple, java.util.Vector implémente cette interface, peut récupérer des éléments aléatoires vector.get(index int).
  • Le groupe Collection peut aussi accéder à son tour en appelant la méthode iterator() pour récupérer l'objet Iterator.
    • java.util.Collection s'étende de l'interface java.lang.Iterable il a donc hérité de la méthode public  Iterator<E> iterator(), la boucle d'itération est utilisée pour naviguer sur les éléments de la Collection.
Sur l'illustration ci-dessus 2 Interface Iterator & RandomAccess, il représente deux façons d'accéder aux éléments d'une compilation.
Voyez la class Vector :
** Vector **
public class Vector<E> extends AbstractList<E>
               implements List<E>, RandomAccess, Cloneable, Serializable
Vector appartient au groupe Collection, vous pouvez accéder à ses éléments par Iterator et aussi par la méthode get (index).

Remarque : Pour les classes du groupe Liste, vous pouvez aussi récupérer l'objet ListIterator, cet itérateur vous permet d'avancer ou de reculer la position du curseur sur la liste au lieu de ne pouvoir avancer qu'à partir de l' Iterator.

5- Groupe Collection

5.1- Les interfaces dans le groupe Collection

Les trois sous-interfaces directes de la Collection sont QueueListe et  Set dans léquelles, Queue est ajoutée à partir de la version 1.5 et considérée comme une file d'attente. Queue a également une sous-interface,  BlockingQueue , qui appartient au paquet  java.util.concurrent, mais nous n'en discutons pas dans cette leçon. Queue est une interface contenant de nombreuses définitions et la façon d'organiser les éléments dont nous devons faire très attention. Trois interfaces  QueueListe ,  Set sont considérées comme trois branches du groupe Collection. Avant d'entrer en détails de chaque groupe, voyons l'aperçu de l'interface Collection.

5.2- java.util.Collection Interface

La relation d’héritage :
** java.util.Collection **
public interface Collection<E> extends java.lang.Iterable<E> {

   //
   // Add element to collection
   // return true if this collection changed as a result of the call
   //
   boolean add(E o);

   //
   // Adds all of the elements in the specified collection to this collection.
   // return true if this collection changed as a result of the call
   //
   boolean addAll(Collection<? extends E> c);

   // Removes all of the elements from this collection (optional operation).
   // The collection will be empty after this method returns.
   void clear();

   // Returns true if this collection contains the specified element.
   boolean contains(Object o);

   // Returns true if this collection contains all of the elements
   // in the specified collection.
   boolean containsAll(Collection<?> c);

   // Compares the specified object with this collection for equality
   boolean equals(Object o);

   int hashCode();

   // Returns true if this collection contains no elements.
   boolean isEmpty();

   //
   // Removes a single instance of the specified element from this
   // collection, if it is present (optional operation).
   //
   boolean remove(Object o);

   // Removes all of this collection's elements that are also contained in the
   // specified collection (optional operation)
   boolean removeAll(Collection<?> c);

   //
   // Retains only the elements in this collection that are contained in the
   // specified collection (optional operation)
   //
   boolean retainAll(Collection<?> c);

   // Returns the number of elements in this collection
   int size();

   // Returns an array containing all of the elements in this collection
   Object[] toArray();

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

   // Returns an iterator over the elements in this collection.
   Iterator<E> iterator();
}

5.3- Accéder les éléments de la collection

Un itérateur sur les éléments de la collection.
Par exemple, utilisation de l'itérateur pour accéder aux éléments de la collection.
CollectionAndIterator.java
package org.o7planning.tutorial.javacollection.collection;

import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;

public class CollectionAndIterator {

	public static void main(String[] args) {

		// Créer un objet Collection vide.
		// Une Collection contient uniquement String.
		Collection<String> coll = new Vector<String>();
		coll.add("Collection");
		coll.add("Queue");
		coll.add("List");
		coll.add("Map");

		// Imprimer le nombre d'éléments de cette collection(collection).
		System.out.println("Size:" + coll.size());

		// Renvoyer l'objet Iterator pour accéder aux éléments de l'ensemble.
		// Cet objet Iterator contient uniquement String.
		Iterator<String> ite = coll.iterator();

		// Vérifier Iteractor qui a un élément suivant ou non?
		while (ite.hasNext()) {
			// Retirer l'élément à la position du curseur
			// Déplacer ensuite le curseur d'un pas de plus.
			String s = ite.next();
			System.out.println("Element:" + s);
		}
	}

}
Les résultats de l'exécution de l'exemple :

5.4- Les branches de la Collection

Comme j'ai mentionné ci-dessus, la Collection a 3 sous interfaces qui sont  Queue, Liste et  Set. La différence entre eux réside dans la manière de stocker les données.
java.util.Queue java.util.List java.util.Set
Permet de contenir des éléments en double Permet de contenir des éléments en double Ne permet pas de contenir des éléments en double
Ne permet pas de contenir des éléments null Permet de contenir des plusieurs éléments null En fonction de la classe implémente l'interface Set, elle prend en charge l'élément null ou non. S'il est pris en charge, il ne contient qu'au plus un élément null.

List

Une List est une liste ordonnée d'objets, où le même objet peut apparaître plus d'une fois. Par exemple : [1, 7, 1, 3, 1, 1, 1, 5]. Il est logique de parler du "N ième" dans une liste. Vous pouvez ajouter un élément n'importe où dans la liste, modifier un élément n'importe où dans la liste, ou supprimer un élément de n'importe quelle position dans la liste.

Queue

Une file d'attente ( Queue) est également ordonnée, mais vous ne toucherez jamais les éléments qu'à une extrémité. Tous les éléments sont insérés à la "fin" et retirés du "début" (ou de la tête) de la file. Vous pouvez savoir combien d'éléments sont dans la file d'attente, mais vous ne pouvez pas savoir quel est, disons, le "troisième" élément. Vous le verrez quand vous y serez.

Set

 Un Set n'est pas ordonnée et ne peut pas contenir de doublons. Vous ne pouvez pas non plus demander l'élément "N ième" ou même le "premier" élément, puisqu'ils ne sont pas dans un ordre particulier. Vous pouvez ajouter ou supprimer des éléments, et vous pouvez savoir si un certain élément existe (par exemple, "7 est-il dans cet ensemble ?").

Remarque SortedSet est une sous-interface de  Set qui peut contenir des éléments ordonnés.

5.5- java.util.List Interface

La Liste est une sous-interface de Collection. Elle possède une multitude de fonctionnalités de Collection, ainsi que certaines fonctionnalités particulières :
  • Accepte des éléments en double
  • Accepte zéro ou plusieurs éléments nuls d'exister.
  • Est un ensemble ordonnéé 
En plus d'accéder en utilisant  Iterator , nous pouvons accéder en utilisant  ListIterator.  ListIterator permet d'avancer ou de reculer le curseur.
// Renvoie l'objet ListIterator, pour parcourir les éléments de la liste.
public ListIterator<E> listIterator()  
 
// Renvoie l'objet ListIterator,
// pour parcourir les éléments de la position d'index "index" à la fin de la liste.
public ListIterator<E> listIterator(int index)
ListAndListIterator.java
package org.o7planning.tutorial.javacollection.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListAndListIterator {

	public static void main(String[] args) {

		// Crée un objet List (Contient seulement String).
		List<String> list = new ArrayList<String>();
		list.add("One");
		list.add("Two");
		list.add("Three");
		list.add("Four");

		// Récupère l'objet ListIterator pour parcourir les éléments de la liste.
		// (Selon l'ordre).
		ListIterator<String> listIterator = list.listIterator();

		// Actuellement, le curseur se trouve à la première position de l'Iterator.
		// Debout à la position d'indice 0. 
		// En sortant le premier élément dans Iterator, le pointeur avance une étape supplémentaire
		String first = listIterator.next();
		System.out.println("first:" + first);// -->"One"

		// Actuellement, le curseur se trouve à l'emplacement qui a l'index 1.
		// Sort l'élément suivant.
		String second = listIterator.next();
		System.out.println("second:" + second);// -->"Two"

		// Vérifie que le curseur peut sauter en arrière une position ou non.
		if (listIterator.hasPrevious()) {
			// Revient en arrière 1 étape.
			String value = listIterator.previous();
			System.out.println("value:" + value);// -->"Two"
		}

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

		while (listIterator.hasNext()) {
			String value = listIterator.next();
			System.out.println("value:" + value);
		}
	}

}
Les résultats de l'exécution de l'exemple :

5.6- java.util.Set Interface

Set est une sous-interface de Collection. Il possède une multitude de fonctionnalités de Collection et a ajouté des certaines fonctionnalités:
  • Décrit un ensemble qui ne permet pas d'éléments en double
  • Autorise un élément null.

HashSetExample.java
package org.o7planning.tutorial.javacollection.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetExample {

	public static void main(String[] args) {

		// ​​​​​​​
		// Créez un objet Set qui a une capacité (capacity) initiale de 10 éléments.
		// Si le nombre d'éléments ajoutés dépasse la capacité actuelle
		// Cela augmentera la capacité de 80%
		// La caractéristique de HashSet est un élément ajouté plus tard se tiendra à l'avant.
		Set<String> set = new HashSet<String>(10, (float) 0.8);

		set.add("One");
		set.add("Two");

		// Lorsque la duplication se produit.
		// Avec HashSet: Il ajoute de nouveaux éléments et supprime les anciens.
		set.add("One");
		set.add("Three");

		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}

}
Les résultats d'exécution de l'exemple :

5.7- java.util.Queue Interface

Queue est un sous-type Interface de Collection, il est plein de fonctionnalités de la Collection, il est assez similaire à la List, cependant, le but d'utilisation est légèrement différent. Queue est conçue pour n'accéder qu'au premier élément de la file d'attente, et lors de la suppression d'éléments, elle supprimera le premier élément de la file. Il est probable qu'il y ait une file d'attente au supermarché, seule la tête de la file d'attente sera servie, les nouveaux arrivants seront insérés dans la file d'attente, la position insérée peut ne pas être la fin de la file. La position de l'élément inséré dépend du type de file d'attente et de la priorité de l'élément.
  • Queue permet aux éléments de dupliquer .
  • Ne pas permettre les éléments null.
Il y a deux classes implémentent d’interface de Queue.
  • java.util.LinkedList
  • java.util.PriorityQueue
LinkedList est une file d'attente assez standard. Mais rappelez-vous que  LinkedList implémente les deux interfaces  List et Queue.

PriorityQueue stocke les éléments en interne dans l'ordre naturel des éléments (si ces éléments sont du type Comparable) ou , selon un Comparator  (Comparateur) sont définies pour  PriorityQueue


Notez qu'une classe peut implémenter des interfaces de Liste et Queue (file d'attente), de sorte que vous n'avez pas besoin de vous soucier de la manière dont les éléments disposés dans la classe interne de la classe ci-dessus, si vous l'avez considérée comme une file d'attente, veuillez consulter la manière d'accéder aux éléments de la queue. Considérons la méthode typique de Queue, elle simule la file d'attente probable des files d'attente au supermarché.
  Throws exception Returns special value
Insert add(e) offer(e)
Remove remove() poll()
Examine element() peek()

boolean add(E)

Insère l'élément spécifié dans cette file d'attente s'il est possible de le faire immédiatement sans violer les restrictions de capacité, retournant vrai en cas de succès et lançant une   IllegalStateException si aucun espace n'est actuellement disponible.

boolean offer(E)

Insère l'élément spécifié dans cette file d'attente s'il est possible de le faire immédiatement sans violer les restrictions de capacité. Lors de l'utilisation d'une file d'attente à capacité limitée, cette méthode est généralement préférable à add(E), qui peut échouer à insérer un élément uniquement en lançant une exception.

E remove()

Récupère et supprime la tête de cette file d'attente. Cette méthode ne diffère du sondage que par le fait qu'elle lève une exception si cette file d'attente est vide.

E poll()

Récupère, mais ne supprime pas, la tête de cette file d'attente. Cette méthode diffère de peek uniquement en ce qu'elle lève une exception si cette file d'attente est vide.

E element()

Récupère, mais ne supprime pas, la tête de cette file d'attente. Cette méthode diffère de peek uniquement en ce qu'elle lève une exception si cette file d'attente est vide.

E peek()

Récupère, mais ne supprime pas, l'en-tête de cette file d'attente, ou retourne null si cette file d'attente est vide.

Commentaire :

Il n'y a pas de méthode parmi les méthodes de file d'attente mentionnées ci-dessus vous permet d'accéder aux autres éléments de la file d'attente, sauf le premier élément, vous ne pouvez pas non plus spécifier l'emplacement de l'élément qui va être inséré.
QueueDemo.java
package org.o7planning.tutorial.javacollection.queue;

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {

	public static void main(String[] args) {

		Queue<String> names = new LinkedList<String>();

		// offre(E) : Insérer un élément dans la file d'attente.
		// Avec LinkedList, l'élément sera inséré à la fin de la file d'attente.
		// Retour vrai si succès.
		// Retourne false si la file d'attente est pleine.
		names.offer("E");
		names.offer("A");
		names.offer("M");

		// ajouter(E) : Insérer un élément dans la file d'attente
		// Avec LinkedList, l'élément sera inséré à la fin de la file d'attente.
		// Retour vrai si succès.
		// Lancez l'exception si la file d'attente est pleine.
		names.add("G");
		names.add("B");

		while (true) {
			// Récupère et supprime la tête de cette file d'attente,
			// ou retourne null si cette file d'attente est vide.
			String name = names.poll();
			if (name == null) {
				break;
			}
			System.out.println("Name=" + name);
		}

	}

}
Les résultats de l'exécution de l'exemple :
 Par exemple avec une file d'attente prioritaire PriorityQueueue. Cette file d'attente stocke ses éléments en interne selon leur ordre naturel (s'ils implémentent Comparable), ou selon un Comparator passé à la PriorityQueue.
String est une classe qui implémente l'interface Comparable et ils peuvent être comparés entre eux et disposés par ordre alphabétique.
PriorityQueueDemo.java
package org.o7planning.tutorial.javacollection.queue;

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueDemo {

	public static void main(String[] args) {

		// Avec PriorityQueue queue, les éléments seront disposés dans l'ordre naturel.
		Queue<String> names = new PriorityQueue<String>();

		// offre(E) : Insérer un élément dans la file d'attente.
		// Retour vrai si succès
		// Retourne false si la file d'attente est pleine.
		names.offer("E");
		names.offer("A");
		names.offer("M");

		// ajouter(E) : Insérer un élément dans la file d'attente.
		// Retour vrai si succès
		// Supprimer l'exception si la file d'attente est pleine.
		names.add("G");
		names.add("B");

		while (true) {
			// Récupère et supprime la tête de cette file d'attente,
			// ou retourne null si cette file d'attente est vide.
			String name = names.poll();
			if (name == null) {
				break;
			}
			System.out.println("Name=" + name);
		}

	}

}
Les résultats de l'exécution de l'exemple :

5.8- Relations en matière d'héritage entre les classes du groupe de Collection

Quelques classes communes :
 
Implementations
Hash Table Resizable Array Balanced Tree Linked List Hash Table + Linked List
Interfaces Set HashSet   TreeSet   LinkedHashSet
List   ArrayList      

5.9- java.util.ArrayList

ArrayList possède de nombreuses fonctionnalités de l'interface Liste. De plus, il permet d'accéder à des éléments aléatoires en raison de l'héritage de RandomAccess.
Fondamentalement, il ressemble à la classe  Vector , la différence est les méthodes de Vecteurs (Vertor) sont synchronisées et  ArrayList ne sont pas.  ArrayList est adapté à l'application  unle flux (1 fil).
ArrayListDemo.java
package org.o7planning.tutorial.javacollection.list;

import java.util.ArrayList;

public class ArrayListDemo {

	public static void main(String[] args) {

		// Créer un objet ArrayList qui contient l'élément de type Integer.
		ArrayList<Integer> list = new ArrayList<Integer>(10);

		// Ajouter des éléments.
		list.add(123);
		list.add(245);
		list.add(new Integer(345));

		// ArrayList permet d'ajouter des éléments nuls.
		// (Caractéristique de la liste)
		list.add(null);

		// Imprimer le nombre d'éléments de cette liste.
		System.out.println("Size:" + list.size());// =4

		// Accéder aléatoire aux éléments de l'index 1.
		Integer i = list.get(1);
		System.out.println("Element index 1 =" + i);// =245
		Integer newInt = 1000;

		// Remplacer l'élément à l'index 
		Integer old = list.set(1, newInt);
		// 
		System.out.println("Old value:" + old);// =245 .
		System.out.println("New value:" + list.get(1));// =1000 .
	}

}
Les résultats de l'exécution de l'exemple :

5.10- java.util.Vector

Vector e est une classe dont les fonctions sont similaires à ArrayList. La différence est que les méthodes de Vector sont synchronisées alors que celles de ArrayList ne le sont pas.

Les méthodes de vecteur sont synchronisées, donc ça fonctionne bien dans les applications Multi Thread.

Vector a quelques méthodes supplémentaires qui sont l'héritage de la version 1.0 avant que le concept de Collection Framework ne soit mentionné en Java.
Les méthodes de Vecteur sont synchronisées, donc faire bon usage dans les applications multi-threads (Thread multiples) 
Vector a quelques méthodes supplémentaires qui sont l'héritage de la version 1.0 avant que le concept de Collection Framework ne soit mentionné en Java.​​​​​​​

// Legacy method from 1.0, get element at index position
// Like get(index)
public E elementAt(int index)


// Method inherited from the List interface, get element at position index.
public E get(int index)

// Replaces the element at the specified position in this list with the specified element
// Return old element.
// setElementAt(int,E) like set(int,E)
public void setElementAt(int index, E element);

// Replaces the element at the specified position in this list with the specified element
// Return old element.
public E set(int index, E element)
VectorDemo.java
package org.o7planning.tutorial.javacollection.list;

import java.util.Vector;

public class VectorDemo {

	public static void main(String[] args) {
		// Créer objet vectoriel avec capacité 10 (élément)
		// Augmenter automatiquement la capacité 5,
		// si le nombre d'éléments permettant de surmonter la capacité actuelle.
		Vector<Integer> v = new Vector<Integer>(10, 5);

		v.add(123);
		v.add(245);
		v.add(new Integer(345));
		v.add(null);

		// Imprimer le nombre d'éléments de ce vecteur. (Pas la capacité).
		System.out.println("Size:" + v.size());// =4

		// Obtenir l'élément à l'index 1
		// (Identique à la méthode get(int))
		Integer i = v.elementAt(1);
		System.out.println("v.elementAt(1)=" + i);// 245

		// Remplacer l'élément à l'index 1.
		v.setElementAt(1, 1000);
		// 
		System.out.println("New value:" + v.get(1));// =1000 .
	}
}
Les résultats de l'exécution de l'exemple :

5.11- java.util.SortedSet

SortedSet est une interface de sous-type de l'interface Set, elle est pleine des fonctionnalités de Set. SortedSet est une catégorie d'ensembles qui ont des arrangements, de nouveaux éléments ajoutés à la catégorie des ensembles se tiennent automatiquement à une position appropriée pour s'assurer que l'ensemble est toujours arrangé (croissant ou descendant).

Par conséquent, les éléments du SortedSet doivent être comparés entre eux, et ils doivent faire l'objet de java.lang.Comparable (Peut être comparable).  Si vous ajoutez un élément qui n'est pas l'objet de Comparable to the SortedSet, vous obtiendrez une exception.
La classe implémente l'interface  SortedSet est  TreeSet 

Considérez la classe de Joueur (le joueur)( Player) y compris les informations : nom, nombre de médailles d'or, nombre de médailles d'argent, nombre de médailles de bronze.

Les joueurs peuvent être comparés entre eux, selon le principe:
  1. Qui a plus de médailles d'or sera plus élevé
  2. Si deux du même nombre de médailles d'or, qui a plus de médaille d'argent sera plus élevé
  3. Si deux personnes ont le même nombre de médailles d'or et d'argent, qui a plus de médailles de bronze que l'autre sera plus élevé.
  4.  D'autres sont considérés comme le même rang. 
Class Player (Classe Joueur) implémentera java.lang.Comparable interface.

Player.java
package org.o7planning.tutorial.javacollection.sortedset;

public class Player implements Comparable<Player> {

	private String name;

	private int goldMedal;
	private int silverMedal;
	private int bronzeMedal;

	public Player(String name, int goldMedal, int silverMedal, int bronzeMedal) {
		this.name = name;
		this.goldMedal = goldMedal;
		this.silverMedal = silverMedal;
		this.bronzeMedal = bronzeMedal;
	}

	// Compare this player with other player
	// If return value < 0 means this player < other
	// If return value > 0 means this player > other
	// If return value = 0 means this player = other
	@Override
	public int compareTo(Player other) {
		// Compare the number of gold medals.
		int value = this.goldMedal - other.goldMedal;
		if (value != 0) {
			return value;
		}
		// Compare the number of silver medals.
		value = this.silverMedal - other.silverMedal;
		if (value != 0) {
			return value;
		}
		// Compare the number of bronze medals.
		value = this.bronzeMedal - other.bronzeMedal;
		return value;
	}

	@Override
	public String toString() {
		return "[" + this.name + ", Gold: " + this.goldMedal //
				+ ", Silver: " + this.silverMedal + ", Bronze: " //
				+ this.bronzeMedal + "]";
	}

}
SortedSetDemo.java
package org.o7planning.tutorial.javacollection.sortedset;

import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetDemo {

	public static void main(String[] args) {

		// Créer un objet SortedSet via la sous-classe TreeSet.
		SortedSet<Player> players = new TreeSet<Player>();

		Player tom = new Player("Tom", 1, 3, 5);
		Player jerry = new Player("Jerry", 3, 1, 3);
		Player donald = new Player("Donal", 2, 10, 0);

		// Ajouter un élément au set
		// Ils seront automatiquement triés (Ascendant).
		players.add(tom);
		players.add(jerry);
		players.add(donald);

		// Imprimer les éléments
		for (Player player : players) {
			System.out.println("Player: " + player);
		}
	}

}
 Les résultats de l'exécution de la classe  SortedSetDemo :

6- Groupe Map

6.1- Les Interfaces au groupe Map

Groupe de Map est dirigé par l'interface java.util.Map. Cette interface a 2 interfaces enfants : j ava.util.SortedMap et java.util.concurrent.concurrent.ConcurrentMap. ConcurrentMap n'appartient pas au paquet java.util, il a été introduit depuis la version java1.5, nous n'y faisons pas référence dans ce document. Groupe de cartes caractérisé par le stockage de données sur les paires clé/valeur.

6.2- Les classes au groupe Map

6.3- java.util.Map Interface

SN Methods with Description
1 void clear( )

Removes all key/value pairs from the invoking map.(optional operation).

2 boolean containsKey(Object k)

Returns true if the invoking map contains k as a key. Otherwise, returns false.

3 boolean containsValue(Object v)

Returns true if the map contains v as a value. Otherwise, returns false

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

Returns a Set that contains the entries in the map. The set contains objects of type Map.Entry. This method provides a set-view of the invoking map.

5 boolean equals(Object obj)

Returns true if obj is a Map and contains the same entries. Otherwise, returns false.

6 Object get(K k)

Returns the value associated with the key k.

7 int hashCode( )

Returns the hash code for the invoking map.

8 boolean isEmpty( )

Returns true if the invoking map is empty. Otherwise, returns false.

9 Set<K> keySet( )

Returns a Set that contains the keys in the invoking map. This method provides a set-view of the keys in the invoking map.

10 Object put(K k, V v)

Puts an entry in the invoking map, overwriting any previous value associated with the key. The key and value are k and v, respectively. Returns null if the key did not already exist. Otherwise, the previous value linked to the key is returned.(optional operation).

11 void putAll(Map<? extends K,? extends V> m)

Puts all the entries from m into this map.(optional operation).

12 Object remove(Object k)

Removes the entry whose key equals k. (optional operation).

13 int size( )

Returns the number of key/value pairs in the map.

14 Collection values( )

Returns a collection containing the values in the map. This method provides a collection-view of the values in the map.

Les méthodes optionnelles (Opération optionnelle), peuvent être supportées sur sa classe d'implémentation ou non, Si non supportée, elle peut lancer  UnsupportedOperationException :
import java.util.Collection;
import java.util.Map;
import java.util.Set;

public class MyMap<K,V> implements Map<K,V>{

   .....
     
     // Si vous appelez cette méthode, une exception sera levée sans condition.
    @Override
    public void clear() {
        throw new java.lang.UnsupportedOperationException();        
    }  

}
Ainsi, la classe  MyMap ne prend pas en charge le sens réel de la méthode  clear (). Si les utilisateurs utilisent intentionnellement cette méthode de  MyMap , ils recevront une exception.
MapDemo.java
package org.o7planning.tutorial.javacollection.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public static void main(String[] args) {

		Map<String, String> map = new HashMap<String, String>();

		map.put("01000005", "Tom");
		map.put("01000002", "Jerry");
		map.put("01000003", "Tom");
		map.put("01000004", "Donald");

		// Obtenir une vue d'ensemble des clés contenues dans cette carte.
		// Cette collection n'est pas triée.
		Set<String> phones = map.keySet();

		for (String phone : phones) {
			System.out.println("Phone: " + phone + " : " + map.get(phone));
		}

	}

}
Les résultats de l'exécution de l'exemple :

Vous pouvez accéder aux données de Map via Map.Entry, voir l'illustration ci-dessous :
MapEntryDemo.java
package org.o7planning.tutorial.javacollection.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class MapEntryDemo {

	public static void main(String[] args) {

		Map<String, String> map = new HashMap<String, String>();

		map.put("01000005", "Tom");
		map.put("01000002", "Jerry");
		map.put("01000003", "Tom");
		map.put("01000004", "Donald");

		// Obtenir un ensemble d'entrées
		// Cette entrée peut ne pas être triée par clé.
		Set<Entry<String, String>> entries = map.entrySet();

		for (Entry<String, String> entry : entries) {
			System.out.println("Phone: " + entry.getKey() + " : " + entry.getValue());
		}

	}
}
Les résultats de l'exécution de l'exemple :

6.4- java.util.SortedMap Interface

SortedMap est la sous-interface de Map. Il garantit que les paires clé /valeur sont disposées par ordre croissant selon la key.
Il n'y a qu'une seule classe dans java.util implémente l'interface SortedMap, c'est TreeMap.
Les méthodes de  SortedMap :
SN Methods with Description
1 Comparator comparator( )

Returns the invoking sorted map's comparator. If the natural ordering is used for the invoking map, null is returned.

2 Object firstKey( )

Returns the first key in the invoking map.

3 SortedMap headMap(Object end)

Returns a sorted map for those map entries with keys that are less than end.

4 Object lastKey( )

Returns the last key in the invoking map.

5 SortedMap subMap(Object start, Object end)

Returns a map containing those entries with keys that are greater than or equal to start and less than end

6 SortedMap tailMap(Object start)

Returns a map containing those entries with keys that are greater than or equal to start.

SortedMapDemo.java
package org.o7planning.tutorial.javacollection.sortedmap;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class SortedMapDemo {

	public static void main(String[] args) {

		Map<String, String> map = new TreeMap<String, String>();

		map.put("01000005", "Tom");
		map.put("01000002", "Jerry");
		map.put("01000003", "Tom");
		map.put("01000004", "Donald");

		// Ce set a été trié par ordre croissant.
		Set<String> keys = map.keySet();
		for (String key : keys) {
			System.out.println("Phone: " + key);
		}

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

		// Ce set a été trié par ordre croissant.
		Set<Map.Entry<String, String>> entries = map.entrySet();
		for (Map.Entry<String, String> entry : entries) {
			System.out.println("Phone: " + entry.getKey());
		}
	}

}
Les résultats de l'exécution de l'exemple :

View more Tutorials: