« Salut Amigo ! »
« Salut, Élie ! »
"Aujourd'hui, nous allons nous concentrer une fois pour toutes sur la structure des collections."
"J'ai attendu longtemps pour ça."
"Vous savez déjà ce que sont les collections et vous savez comment travailler avec elles. Il est temps d'organiser vos connaissances dans un système strict. Ensuite, de nombreuses questions "pourquoi" et "comment" disparaîtront, et la plupart des choses deviendront évidentes. "
" Interfaces de collection . La structure d'héritage des interfaces de collection ressemble à ceci :"
Remarquez deux choses.
Tout d'abord, tout ce que vous voyez ici est une interface.
Deuxièmement, les flèches signifient « hérite ».
"En d'autres termes, List, Set et Queue héritent de Collection, mais pas Map ?"
"Oui. Les classes abstraites héritent alors de ces interfaces et, à leur tour, les implémentations que vous connaissez héritent de ces classes abstraites : ArrayList, Hashtable, TreeSet,… "
"Tu as raison."
"Voyons maintenant à quoi servent les méthodes de ces interfaces :"
Méthodes de l' interface Iterable<E> : :
| Méthodes | Description |
|---|---|
Iterator<T> iterator(); |
Renvoie un objet itérateur. |
"Cela ne semble pas suffisant."
"Eh bien, c'est le nombre qu'il y en a. C'est tout pour les itérateurs. Nous ne les couvrirons pas pour le moment, mais nous les couvrirons en détail bientôt."
Méthodes de la Collection<E> : interface :
| Méthodes | Description |
|---|---|
boolean add(E e); |
Ajoute un élément à la collection |
boolean addAll(Collection<? extends E> c); |
Ajoute des éléments à la collection |
void clear(); |
Supprime tous les éléments de la collection |
boolean contains(Object o); |
Vérifie si la collection contient l'élément. |
boolean containsAll(Collection<?> c); |
Vérifie si la collection contient les éléments. |
boolean equals(Object o); |
Vérifie si les collections sont équivalentes |
int hashCode(); |
Renvoie le code de hachage |
boolean isEmpty(); |
Vérifie si la collection est vide. |
Iterator<E> iterator(); |
Renvoie un objet itérateur |
boolean remove(Object o); |
Supprime un élément de la collection |
boolean removeAll(Collection<?> c); |
Supprime des éléments de la collection |
boolean retainAll(Collection<?> c); |
Supprime tous les éléments qui ne sont pas dans c |
int size(); |
Renvoie la taille de la collection |
Object[] toArray(); |
Convertit la collection en tableau |
<T> T[] toArray(T[] a); |
Convertit la collection en tableau |
"Je suis déjà solide sur tout ici. J'ai utilisé la moitié de ces méthodes et j'ai rencontré l'autre moitié."
"Génial, continuons alors."
Méthodes de l' interface List<E> :
| Méthodes | Description |
|---|---|
void add(int index, E element); |
Ajoute des éléments au milieu de la collection |
boolean addAll(int index, Collection<? extends E> c); |
Ajoute des éléments à la collection |
E get(int index); |
Renvoie un élément par index |
int indexOf(Object o); |
Renvoie l'indice (numéro) d'un élément |
int lastIndexOf(Object o); |
Renvoie l'indice du dernier élément. |
ListIterator<E> listIterator(); |
Retourne un itérateur pour la liste |
ListIterator<E> listIterator(int index); |
Retourne un itérateur pour la liste |
E remove(int index); |
Supprime un élément par son index |
E set(int index, E element); |
Définit une nouvelle valeur par index |
List<E> subList(int fromIndex, int toIndex); |
Renvoie une sous-collection |
"Ici non plus rien de radicalement nouveau. Je connais déjà presque tout sur les collections, ce dont je ne peux m'empêcher de me réjouir."
"Eh bien, je pense que je peux trouver quelque chose qui va vous surprendre. Mais continuons à examiner les interfaces :"
Méthodes de l' interface Set<E> : :
| Méthodes | Description |
|---|---|
|
|
|
"L'interface Set n'a pas de nouvelles méthodes - seulement celles dont elle hérite."
"Oui, j'ai vu que l'interface Interable n'avait rien non plus.
"D'un autre côté, moins de méthodes signifie moins à retenir !"
"Votre optimisme qui affirme la vie me rend heureux."
"L'interface Set est héritée par deux interfaces avec des méthodes : SortedSet et NavigableSet. Mais je ne les passerai pas en revue, sinon nous ne finirons jamais."
"Au lieu de cela, laissez-moi vous donner une image générale des classes et des interfaces qui décrivent les collections en Java."
"L'amener sur."
"Alors tiens bon :"
« Wow, c'est énorme !
"Eh bien, ce n'est pas si gros. Aussi, rappelez-vous que les classes abstraites sont entièrement facultatives. Mais il est bon de se rappeler quelle classe implémente quelles interfaces. Cela peut être utile assez fréquemment."
"Oh, je voudrais également souligner que certaines collections sont considérées comme obsolètes."
« Quels sont ceux-là ?
"Je parle des classes Vector, Stack, Dictionary et Hashtable. Ce sont des versions synchronisées (thread-safe) des collections ordinaires."
"Mais Java a ajouté une bibliothèque de concurrence spéciale avec de nombreuses collections qui non seulement sont accessibles à partir d'autres threads, mais ont également une implémentation beaucoup plus efficace. ConcurrentHashMap est beaucoup plus efficace que Hashtable ."
"Vous pouvez utiliser les collections Vector, Stack, Dictionary et Hashtable, mais ce n'est pas recommandé."
"Je l'ai, je vais garder cela à l'esprit."
« Merci, Élie ! »
GO TO FULL VERSION