Tutoriel Java Collections Framework

View more Tutorials:

1- Introduction

Le groupe est une idée de base du programme et le langage de programmation. Une application régulière de travailler avec l'ensemble d'exemples tels que le stockage de l'information au personnel, une série de photos...Java comme les autres langues aide les tableaux ( array) comme l'ensemble de base, fini de travailler avec des tableaux est pas pratique dans de nombreux cas en raison de la durée de vie de l'élément de tableau pour ajouter ou supprimer est difficile et coûteux de la performance du programme l'élément du tableau, si délibérément le faire.
L'image illustre un plaque:

2- Premier exemple

Tout d'abord, nous faisons 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");

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

		// Insère 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);

		// Supprimez l'élément premier et le dernier 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);

		// Retirez 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);
	}

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

import java.util.HashMap;

public class HelloHashMap {

	public static void main(String[] args) {

		// Créez un objet HashMap qui stocke les paires, les ID d'employés et les 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);
		
		// Sortez 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"));
		 
	}

}
Résultats de l'exécution de l'exemple:

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

3.1- Tableaux - un ensemble de types de base.

  • Plaque est très base et familier .
    • lStocke le types de  la référence, le type primitif
    • int[] myArray=new int[]{1,4,3};
    • Object[] myArrayObj =new Object[]{"Object",new Integer(100)};
  • Plaque a la taille et le nombre de dimensions fixe
    • Difficile pour élargir la plaque
    Les éléments sont placés et référencé de façon successive en mémoire.
    • Difficile de supprimer un élément de la plaque

3.2- Supprimez l'élément de tableau

Les éléments d'un tableau est placé consécutivement dans la mémoire qui est difficile lorsque vous quittez délibérément un certain élément du tableau, il est perdu consécutive. Normalement, une technique qui est souvent utilisée est de créer un nouvel objet de stockage de tableau du tableau d'origine et supprimer les éléments inutiles, mais cela réduit les performances du programme. Avec la gamme élargie des cas également avec la technique similaire est créé un nouveau tableau avec une taille plus grande, puis copier les anciens éléments de tableau dans le nouveau tableau .
Il est évident que le tableau n'est pas un bon moyen pour de nombreux cas d'application.

3.3- Liste avec connexion

Liste des connectés ( liste chaînée)( Linked List) est l'une des façons de gérer la liste des données sont les inconvénients de la plaque. Bien sûr pour gérer liste en Java il y a beaucoup d'autres moyens par exemple  ArrayList .

  Voyez les caractéristiques de  LinkedList:
  • Les éléments de cette liste peuvent être placés ensemble isolement (non consécutifs) dans la mémoire.
  • C'est vraiment un lien entre les propriétés des éléments.
    • Chaque élément de la liste contient une référence à l'élément avant et référence immédiatement après son élément.
LinkedList est vraiment un lien à deux voies .
L'élément Link est un objet qu'il contient  les données dont vous avez besoin pour gérer (données), et il a deux références à l'élément Link avant et derrière .
Comme un groupe de personnes alignées, chaque personne a besoin juste des gens debout devant qui ils sont et les gens derrières eux qui sont
Supprimer un élément de LinkedList​​​​​​​
Supprimer un élément de  LinkedList comme mettre une personne hors de la ligne sont disposés,  les deux hommes qui se tenaient près de la personne pour mettre à jour les informations des personnes debout avant, derrière qui ils sont.
Ajoutez 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 est terminée, elle nous a aussi fait comprendre plus de  package java.util.
Remarque: LinkedList est l'une des solutions pour résoudre les limites des tableaux, ArrayList est aussi un moyen de gérer des ensembles de données, résout les limites des tableaux, mais la façon de gérer ses données plus.

4- Vue d'ensemble de Java Collections Framework

Voir les limites du tableau à partir de java version 1.0 a pris sur la classe  java.util.Vector une liste d'archives de classe d'objets. Et java.util.Hashtable est classe stocke les paires clé/valeur (clé/valeur). Puis la plate-forme Java2 continue de recommander l'approche à la collection, connue comme le cadre de Collections (la Fondation)java.util.Vector, java.util.Hashtable existe toujours et fait maintenant partie d'une grande plate-forme. Le type de cette collection est construite sur la base d'un certain nombre d'interface dans le bundle  java.util. Et se divise à  la hiérarchie dirigée par deux interfaces  java.util . Collection contient une liste d'objets et   java.util.Map contenant des paires clé/valeur.

4.1- Les Interfaces dans le cadre des collections Java(Java Collections Framework)

L'image ci-dessus est l'interface importante de Java Collections Framework . On parlera  de l'objectif d'utilisation de l'interface et les diviser par but et utiliser. Dans le bundle  java. util l'implémentation de la classe d'interface d'un ou plusieurs. Donc, une classe dans  java.util peut avoir beaucoup de caractéristiques différentes. Par exemple java.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 - Comment il contient des données

  • Le groupe Collection stockée des objets
    •  il y a trois petites branches dans le groupe Collection: Queue, List, Set .
    • L'élément peut être la même ou non dépend de la branche des trois branches au-dessus.( Sera mentionné plus loin).
  • Groupe Map stocke de couples key/value ( clé/valeur)
    • Les couples key/value contient dans Map (Map) est toujours différent clés entre les couples
    • Si vous connaissez key peut récupérer la valeur de la valeur dans le Map avec cette clé
Groupe Collection stocke les données qui sont les types de référence, groupe  Map stocke les couples   clé/valeur ( key/value) 
Collection<String> c=new ArrayList<String>();
// Ajoutez l'élément à la collection.
c.add("One");


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

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

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

4.3- Interface Iterator et interface RandomAccess - Comment on récupère des données

  • java.util.Iterator
    •  Comme une boucle pour obtenir les données, l'accès de cet élément à un autre élément.
  • java.util.RandomAccess
    • Méthode d'accès aléatoire, par exemple pour positionner les é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 l'élément aléatoire vector.get(index int).
  • Le groupe Collection peut également accéder à son tour de style en appelant la méthode iterator () pour récupérer l'objet d'itérateur (Iterator) .
    • java.util.Collection s'étendant de l'interface java.lang.Iterable (peut répéter) de sorte qu'il a hérité de la méthode iterator < E> itérateur (), la boucle d'itération est utilisée pour naviguer sur les éléments de la Collection.
Sur l'illustration ci-dessus possède deux Interface Itérateur& RandomAccess, il représente les deux  façons d'accéder aux éléments dans un ensemble.
Voyez class Vector:
** Vector **
public class Vector<E> extends AbstractList<E>
               implements List<E>, RandomAccess, Cloneable, Serializable
Selon le Vecteur ci-dessus dans la Collection, vous pouvez accéder à ses éléments par Iterator et peut également être consulté au hasard par la méthode  get(index).
Remarque : pour les objets dans le groupe de Liste vous pouvez également récupérer les objets  ListIterator , ce répéteur vous permet de reculer et de déplacer la position du curseur sur la liste au lieu de ne pouvoir qu'avancer à partir de l' I térateur.

5- Groupe Collection

5.1- Les interfaces dans le groupe Collection

Trois sous-interfaces directes de la Collection sont QueueListe et  Set. Dans lequel, Queue est ajouté à partir de la version 1.5 et considéré comme une file d'attente. Queue a également une sous-interface,  BlockingQueue , qui appartient au paquetage 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 accorder la plus grande attention. Trois interface QueueListe ,  Set sont considérées comme trois branches du groupe Collection. Avant d'afficher les 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- Parcourez les éléments de la collection

Itérateur est un moyen pour vous naviguer sur les éléments de l'ensemble
L'exemple de l'utilisation d'Itérateur ( Iterator ) 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éez 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");

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

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

		// Vérifiez Iteractor qui a un élément suivant ou non?
		while (ite.hasNext()) {
			// Retirez l'élément à la position du curseur
			// Déplacez 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 petites branches de la collection

Comme  ci-dessus mentionné la Collection a 3 files  sont  Queue, Liste et  Set. Et la différence entre eux est de savoir comment 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 liste ( List) est une liste séquentielle d'objets, où des objets similaires peuvent apparaître une ou plusieurs fois. Par exemple: [1, 7, 1, 3, 1, 1, 1, 5]. Et vous pouvez parler de l'élément "Nième" dans la liste. Vous pouvez ajouter un élément à n'importe quelle position de la liste, en modifier un élément à une certaine position de la liste ou supprimer un élément à n'importe quelle position de la liste.

Queue

Les files d'attente ( Queue) sont également une collection séquentielle, mais vous ne pouvez toucher que l'élément permanent en haut de la file d'attente. Tous les éléments sont insérés à la fin de la file d'attente et suppriment le premier élément de la file d'attente. Vous pouvez voir combien d'éléments sont dans la file d'attente, mais vous ne pouvez pas trouver ni parler d'élément Nième, vous ne pouvez le voir que lorsqu'il apparaît en tête de liste.

Set

Set est une collection non séquentielle et ne permet pas en double. Vous ne pouvez pas dire l'élément Nième même le premier élément, parce qu'il n'a pas la séquence. Vous pouvez ajouter ou supprimer des éléments et vous pouvez savoir si elle existe vraiment (par exemple, "7 est dans cette collection?").

NoteSortedSet 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. Il possède une multitude de fonctionnalités de Collection, ainsi que certaines fonctionnalités spéciales:
  • Permettre les éléments en double
  • Permettre à zéro ou à plusieurs éléments nuls d'exister.
  • Être l'ensemble séquentielle-ment 
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éer 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).
		// Returns a list iterator over the elements in this list
		// (in proper sequence)
		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.
		// Sortir l'élément suivant.
		String second = listIterator.next();
		System.out.println("second:" + second);// -->"Two"

		// Vérifiez que le curseur peut sauter en arrière une position ou non.
		if (listIterator.hasPrevious()) {
			// Revenir 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écrivez un ensemble qui ne permet pas d'éléments en double
  • Permettre à des éléments s'il y a l'élément nul puis seulement un élément.

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ée 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 de l'exécution de l'exemple:
 

5.7- java.util.Queue Interface

 Queue (file d'attente) est un sous-type Interface de Collection, il a toutes les fonctionnalités de la Collection, il est assez similaire à la Liste, mais le but d'utilisation est légèrement différente. Queue est conçu pour accéder uniquement au premier élément de la file d'attente, et lors de la suppression des éléments, il supprime le premier élément de la file d'attente. Il est probable que la ligne de personnes qui font la queue au supermarché, seul le chef de file sera servi, 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 ligne. La position de l'élément inséré dépend du type de file d'attente et de la priorité de l'élément.
  • Être l'ensemble qui permet les éléments en double.
  • 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 Comparateur (comparaison) 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 s'il est possible de le faire immédiatement sans violer les restrictions de capacité, renvoyant vrai lors de la réussite et lançant une exception illégale si aucun espace n'est actuellement disponible.

boolean offer(E)

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

E remove()

Sortez et supprime le premier élément est toujours une file d'attente. Cette méthode diffère de  poll () en ce que s'il n'y a pas de file d'attente exception d'élément sera jeté.

E poll()

Sortez et supprime le premier élément est toujours une file d'attente, ou renvoie  null si la file d'attente n'a pas d'élément.

E element()

Sortir, mais ne supprime pas l'élément de la première file d'attente. Cette méthode diffère de  peek () est qu'elle génère une exception s'il n'y a pas de file d'attente élément.

E peek()

Sortir, mais ne supprime pas l'élément de la première file d'attente, ou renvoie  null si la file d'attente n'a pas d'élément.

Commentaire:

La méthode de la file d'attente ci-dessus qui n'a pas aucune méthode vous permet d'accéder à d'autres éléments dans la file d'attente en dehors du premier élément, vous ne pouvez pas spécifier l'emplacement de l'élément sera sur la cible.
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): ajoute un élément à la file d'attente (queue).
		// Avec la file d'attente LinkedList l'élément sera inséré à la fin de la file d'attente.
		// Renvoie true si l'insertion réussit.
		// Renvoie false si la file d'attente est vide.
		names.offer("E");
		names.offer("A");
		names.offer("M");

		// add(E): Ajoute un élément à la file d'attente.
		// Avec la file d'attente LinkedList, l'élément sera inséré à la fin de la file d'attente.
		// Renvoie true si l'insertion réussit.
		// Jetez l'exception si la file d'attente n'est plus disponible
		names.add("G");
		names.add("B");

		while (true) {
			// Sortez-le et supprimer le premier élément de la file d'attente.
			// Renvoie null s'il n'y a aucun élément dans la file d'attente.
			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 a priorité  PriorityQueue . Cette file d'attente est stocké dans les composants internes de l'ordre des éléments naturels (si les éléments qui comparent les uns aux autres - mettre en oeuvre Comparable) ou un Comparateur de comparaison est réglé pour la foudre  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 la file d'attente (queue) PriorityQueue l'élément sera positionné
		// dans leur ordre naturel.
		Queue<String> names = new PriorityQueue<String>();

		// offer (E): Ajoute un élément à la file d'attente.
		// Renvoie true si ajouté réussit
		// Renvoie false si la file d'attente est vide.
		names.offer("E");
		names.offer("A");
		names.offer("M");

		// add(E): Ajoute un élément à la file d'attente. (queue).
		// Renvoie true si ajouté réussit
		// Jeter une Exception si la file d'attente est pleine.
		names.add("G");
		names.add("B");

		while (true) {
			// poll (): Sort et supprime le premier élément de la file d'attente.
			// Renvoie null s'il n'y a pas d'élément dans la file d'attente.
			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- Les relations d'héritage des classes dans le groupe Collection

Certaines 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 a toutes les fonctionnalités de l'interface de la Liste. En même temps, il a la capacité d'accéder à un élément aléatoire (par héritage de l'interface  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) {

		// Déclarez un objet ArrayList contenant des éléments 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 null.
		// (Caractère de liste)
		list.add(null);

		// Imprimez le nombre d'éléments dans ArrayList.
		System.out.println("Size:" + list.size());// =4

		// ​​​​​​​
		// Accès aléatoire à l'élément à l'index 1.
		Integer i = list.get(1);
		System.out.println("Element index 1 =" + i);// =245
		Integer newInt = 1000;

		// Remplacer l'élément à la position avec l'index 1.
		// Cette méthode renvoie l'ancien élément.
		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 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 soit mentionné en Java.

Les méthodes de Vecteur sont synchronisées, donc faire bon usage dans les applications multi-threads (Thread multiples) 
Vector ajoute quelques méthodes qui sont l'héritage de la version 1.0 avant que l le concept de plateforme d’agrégation 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) {
		// Initialiser un objet Vector.
		// Avec une capacité (capacity) initiale de 10 éléments.
		// Augmente automatiquement la capacité de 5 si le nombre d'éléments est plus grand
		// capacité actuelle.
		Vector<Integer> v = new Vector<Integer>(10, 5);

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

		// Imprimez le nombre d'éléments réellement au Vecter (pas la capacité)
		System.out.println("Size:" + v.size());// =4

		// Retirez l'élément à l'index 1
		// Comme les méthodes get (int).
		Integer i = v.elementAt(1);
		System.out.println("v.elementAt(1)=" + i);// 245

		// Remplacez l'élément à l'index 1.
		// Replace element at 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 de fonctionnalités de  SetSortedSet est une catégorie d'ensembles qui ont des arrangements, les nouveaux éléments ajoutés à la catégorie d'ensembles se tiennent automatiquement à une position appropriée pour s'assurer que l'on arrête toujours (ascendant ou descendant).

Par conséquent, les éléments du SortedSet doivent être comparés entre eux, et ils doivent faire l'objet de j ava.lang.Comparable (Peut être comparable). Si vous ajoutez un élément qui n'est pas l'objet de Comparable à SortedSet, vous obtiendrez une exception.
Une des classes implémentes 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ée 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 des éléments à une collection.
		// Ils seront automatiquement triés (croissant).
		players.add(tom);
		players.add(jerry);
		players.add(donald);

		// Imprimez 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

Grouoe de Map est dirigé par l'interface java.util.Map. Cet Interface à deux sous-interface est java.util.SortedMap et java.util.concurrent.ConcurrentMap. ConcurrentMap  n'appartient pas au paquet java.util il est entré dans la version de java1.5, nous n'avons pas mentionné dans ce document. Groupe de Map caractérisé par le stockage des données par 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 de l'option (opération facultative) (Opération optionnelle) peuvent être prises en charge par l'implémentation de la classe de celui-ci ou non, dans le cas n'est pas pris en charge peut jeter   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 inconditionnellement.
    @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");

		// Sortir une collection qui contient des clés (key).
		// 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");

		// Lấy ra một tập hợp của các entry.
		// Ces entry peuvent ne pas être triés 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 clé.
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");

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

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

		// Cette collection a également été triée par clé.
		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: