Tutoriel Java Collections Framework

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

}

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"));
		 
	}

}

public class HashMap<K,V> extends AbstractMap<K,V>
                           implements Map<K,V>, Cloneable, Serializable

public class Vector<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, Serializable

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));

public class Vector<E> extends AbstractList<E>
               implements List<E>, RandomAccess, Cloneable, Serializable

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();
}

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

}

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

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

}

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());
		}
	}

}

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

	}

}

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

	}

}

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 .
	}

}

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

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(1000, 1);
		// 
		System.out.println("New value:" + v.get(1));// =1000 .
	}
}

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 + "]";
	}

}

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

}

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();        
    }  

}

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

	}

}

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());
		}

	}
}

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());
		}
	}

}