mika-el
3/16/2018 - 2:57 PM
Collections
SortedMap
Cette interface permet de stocker des éléments ordonnés par ordre croissant, très utile pour des listes de numéros de téléphone, de dictionnaire etc.
Queue
Ce type de collections peut s'apparenter à une file d'attente. Ce sera à vous de gérer la façon d'ordonner les éléments qu'elles contiennent.
List
Cette interface se présente sous la forme d'une liste ordonnée qui accepte les valeurs en double. Vous avez donc intérêt à contrôler parfaitement le contenu de vos données si vous utilisez ce type d'interface !
/*
- List Category
- Import java.util.*
- Vector, LinkedList, ArrayList...
- tableaux extensibles à volonté */
/*
- LinkedList
- Chaque élément contient une référence à l'élément précédent et à l'élément suivant,
- exceptés le premier, dont l'élément précédent vaut null,
- et le dernier, dont l'élément suivant vaut également null. */ import java.util.LinkedList; import java.util.List; import java.util.ListIterator; public class Test { public static void main(String[] args) { List list = new LinkedList(); list.add(12); for(int i = 0; i < list.size(); i++) { System.out.println("Élément à l'index " + i + " = " + list.get(i)); } // Avec Iterator ListIterator listI = list.listIterator(); while(listI.hasNext()) { System.out.println(listI.next()); } } }
/*
- ArrayList
- Objets qui n'ont pas de taille limite et qui, en plus, acceptent n'importe quel type de données, y compris null.
- Contrairement aux LinkedList, les ArrayList sont rapides en lecture, même avec un gros volume d'objets.
- Elles sont cependant plus lentes si vous devez ajouter ou supprimer des données en milieu de liste.
- Pour résumer à l'extrême, si vous effectuez beaucoup de lectures sans vous soucier de l'ordre des éléments, optez pour une ArrayList.
- En revanche, si vous insérez beaucoup de données au milieu de la liste, optez pour une Linkedlist. */
/*
- add() permet d'ajouter un élément.
- get(int index) retourne l'élément à l'indice demandé ;
- remove(int index) efface l'entrée à l'indice demandé ;
- isEmpty() renvoie « vrai » si l'objet est vide ;
- removeAll() efface tout le contenu de l'objet ;
- contains(Object element) retourne « vrai » si l'élément passé en paramètre est dans l'ArrayList.
*/
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ArrayList array = new ArrayList();
array.add(12);
for(int i = 0; i < array.size(); i++) {
System.out.println("donnée à l'indice " + i + " = " + array.get(i));
}
} }
Création due liste de new qui contiend des Map de titre, contenu:
dans la servlet
List<Map<String, String>> maListe = new ArrayList<Map<String, String>>();
Map<String, String> news = new HashMap<String, String>();
news.put("titre", "Titre de ma première news");
news.put("contenu", "corps de ma première news");
maListe.add(news);
news = new HashMap<String, String>();
news.put("titre", "Titre de ma seconde news");
news.put("contenu", "corps de ma seconde news");
maListe.add(news);
dans la JSP
<c:forEach items="${maListe}" var="news">
<div class="news">
<div class="titreNews">
<c:out value="${news['titre']}" />
</div>
<div class="corpsNews">
<c:out value="${news['contenu']}" />
</div>
</div>
</c:forEach>
/*
* Map Category
* Hashtable, HashMap, TreeMap, WeakHashMap …
* Collection qui fonctionne avec un couple clé - valeur.
* La clé, qui sert à identifier une entrée dans notre collection, est unique.
* La valeur, au contraire, peut être associée à plusieurs clés.
*/
/*
* Hashtable
* On parcourt cet objet grâce aux clés qu'il contient en recourant à la classe Enumeration.
* Hashtable n'accepte pas la valeur null.
* Il est Thread Safe (plusieurs éléments de votre programme peuvent l'utiliser simultanément sans qu'il y ait un risque de conflit de données)
* Il remplace la valuer de la clé si elle existe déjà.
*/
import java.util.Enumeration;
import java.util.Hashtable;
public class Test {
public static void main(String[] args) {
Hashtable hashtable = new Hashtable();
hashtable.put(1, "printemps");
Enumeration enumeration = hashtable.elements();
while(enumeration.hasMoreElements()) {
System.out.println(enumeration.nextElement());
}
}
}
/*
* HashMap
* Il accepte la valeur null.
* Il n'est pas Thread Safe.
* Il remplace la valuer de la clé si elle existe déjà.
*/## Set
Cette interface permet donc de stocker des objets. Normal, c'est une collection ! Mais les classes implémentant cette interface ne tolèrent pas les doublons de données. Ainsi, ce genre de collection est tout indiqué pour gérer des éléments uniques : un calendrier, une liste de cartes à jouer etc.
/*
* Set Category
* HashSet, TreeSet, LinkedHashSet …
* Certains Set sont plus restrictifs que d'autres : il en existe qui n'acceptent pas null, certains types d'objets, etc...
* Les Set sont particulièrement adaptés pour manipuler une grande quantité de données.
* Généralement, on opte pour un HashSet, car il est plus performant en temps d'accès, mais si vous avez besoin que votre collection soit constamment triée, optez pour un TreeSet.
*/
/*
* HashSet
* C'est sans nul doute la plus utilisée des implémentations de l'interface Set.
* On peut parcourir ce type de collection avec un objet Iterator ou extraire de cet objet un tableau d'Object.
*/
/*
* add() ajoute un élément ;
* contains(Object value) retourne « vrai » si l'objet contient value ;
* isEmpty() retourne « vrai » si l'objet est vide ;
* iterator() renvoie un objet de type Iterator ;
* remove(Object o) retire l'objet o de la collection ;
* toArray() retourne un tableau d'Object.
*/
import java.util.HashSet;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
hashSet.add("toto");
Iterator iterator = hashSet.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
// Parcours avec un tableau d'objet
Object[] objHashSet = hashSet.toArray();
for(Object o : objHashSet) {
System.out.println(o);
}
}
}