java collections framework tutorial
Ce didacticiel explique en détail Java Collections Framework (JCF) ainsi que la hiérarchie des collections, diverses interfaces et les avantages de JCF:
J'espère que ces tutoriels éloquents à ce sujet Série Java pour les débutants sont vraiment utiles pour enrichir vos connaissances de Java.
Notre précédent tutoriel nous a expliqué plus en détail opérations d'E / S de base en Java . Dans ce didacticiel, nous découvrirons en détail Java Collections Framework (JCF).
Java Collections Framework (JCF) contient des interfaces, des classes abstraites et des classes qui peuvent fournir l'architecture pour stocker et manipuler un groupe d'objets.
Ce que vous apprendrez:
- Tutoriels vidéo sur le framework de collections Java
- Besoin d'un cadre de collecte
- Framework de collections Java
- Hiérarchie des collections Java
- Interface de collecte
- Interface itérable
- Interface d'itérateur
- Interface de liste
- Interface de file d'attente
- Définir l'interface
- Interface SortedSet
- Avantages de Java Collections Framework
- Questions fréquemment posées
- Conclusion
Tutoriels vidéo sur le framework de collections Java
Connaissance d'Arraylist en Java:
Définissez l'interface et l'interface de file d'attente en Java avec des exemples en temps réel:
HashMap, TreeMap et HashTable en Java:
Jusqu'à présent, nous avons vu des variables qui stockent différents types de données. Ce sont des unités uniques et ne sont pas très utiles lorsque vous avez d'énormes quantités de données à stocker et à traiter. Comme nous le savons, les données sont le composant le plus important du traitement informatique.
Votre application doit être capable d'extraire et de collecter des données, de les traiter pour trouver des informations utiles et également de les faire circuler afin qu'elles soient utilisées efficacement pour atteindre les solutions.
Dans ce monde logiciel, nous stockons les données qui doivent être structurées de manière particulière afin que les logiciels soient capables de stocker, lire, traiter et enfin sortir les résultats. Cela se fait à l'aide de structures de données.
Presque tous les langages de programmation prennent en charge les structures de données. La structure de données peut être définie comme une représentation structurée de données. Les langages de programmation fournissent des fonctions API (Application Programming Interface) afin de manipuler les structures de données.
Besoin d'un cadre de collecte
Avant Java 1.2, le langage de programmation Java prenait en charge les structures de données telles que les tableaux, les vecteurs ou les tables de hachage. Effectuer des opérations sur ces structures de données n'a pas été facile car il n'y avait pas d'interface commune qui fonctionnait sur ces structures de données.
Les programmeurs avaient du mal à écrire des algorithmes qui fonctionneraient pour toutes les structures de données et c'était un gros problème. Il fallait une interface commune qui fonctionnerait de manière cohérente sur toutes les structures de données et mènerait également des opérations efficacement.
Plus tard, Java a proposé un cadre de collecte qui est un groupe de classes et d'interfaces composé de diverses opérations pouvant être effectuées sur des structures de données.
Dans ce didacticiel Java Collections, nous aborderons le Java Collections Framework en général. Nous explorerons chacun des composants de la collection dans nos prochains tutoriels.
Framework de collections Java
Avant de définir un framework de collections Java, apprenons à connaître la signification d'une collection et d'un framework.
Une collection peut être définie comme un groupe d'objets. Une collection est généralement une seule unité composée de plus d'un objet. Un framework est un logiciel qui a une interface ou une architecture fonctionnelle prête à l'emploi et contient également un ensemble de classes et d'interfaces à utiliser avec l'interface fournie.
Un framework de collections est défini comme une architecture unifiée et prête à l'emploi composée des éléments ci-dessous.
# 1) Algorithmes
Ce sont des méthodes ou un ensemble d'instructions qui peuvent aider les programmeurs à rechercher, trier et traiter les données collectées. La collection est livrée avec des interfaces, des classes et des algorithmes.
Les applications développées en héritant du framework de collecte ont accès à ces algorithmes et utilisent les méthodes et procédures déjà définies.
# 2) Interfaces
Les interfaces en Java fournissent l'abstraction de l'implémentation, c'est-à-dire qu'en utilisant des interfaces, l'utilisateur n'est pas au courant des détails de l'implémentation, mais ne peut voir que les méthodes et les données nécessaires pour écrire une application. L'interface de collection a de nombreuses interfaces qui peuvent être implémentées par le programmeur pour écrire ses propres classes.
# 3) Cours
Les classes de Collection Framework sont des structures de données qui peuvent être implémentées dans un programme. Ces classes implémentent l'interface «Collection» et héritent ainsi de toutes les méthodes et définitions de l'interface de collection.
Un framework de collection est utilisé pour stocker et manipuler la collection qui est le groupe d'objets.
Le framework de collecte Java se compose d'algorithmes hautement performants qui effectuent des opérations standard telles que la recherche, le tri et le traitement. Il fournit diverses implémentations standard, notamment LinkedList, TreeSet et HashSet pour lesquelles des interfaces sont fournies.
Voyons ensuite la hiérarchie des collections Java.
Hiérarchie des collections Java
Toutes les classes et interfaces présentées dans la hiérarchie de la collection Java ci-dessous appartiennent au package «java.util. *».
Comme le montre le diagramme ci-dessus, la hiérarchie de collection Java se compose de différentes classes et interfaces. Comme vous pouvez le voir, chacune des classes hérite d'une interface et toutes les classes et interfaces, à leur tour, héritent d'une seule interface de «collection».
Discutons de quelques méthodes courantes dans l'interface de collecte avec une brève introduction sur chacune des classes et interfaces qui sont affichées dans la hiérarchie ci-dessus.
Interface de collecte
L'interface de collection est l'interface racine. Toutes les classes du framework de collection implémentent l'interface de collection. Cela signifie que chaque collection aura les méthodes déclarées dans l'interface Collection.
Certaines des méthodes de l'interface Collection sont données ci-dessous.
| Ne pas | Prototype de méthode | Description |
|---|---|---|
| 7 | default boolean removeIf (filtre de prédicat) | Supprimez tous les éléments qui satisfont le prédicat «filtre» donné de la collection. |
| 1 | public int size () | Renvoie le nombre d'éléments dans une collection donnée. |
| deux | public void clear () | Efface la collection en supprimant tous les éléments de la collection. |
| 3 | public booléen add (E e) | Insère un élément e dans la collection. |
| 4 | public booleanaddAll (Collection c) | Insérez tous les éléments de la collection donnée par c dans la collection. |
| 5 | public boolean remove (élément Object) | Supprimer l’élément donné par ‘élément’ de la collection. |
| 6 | public boolean removeAll (Collectionc) | Supprimez la collection c de la collection. |
| 8 | public booleanretainAll (Collection c) | Supprimer tous les éléments de la collection à l'exception de ceux de la collection spécifiée c. |
| 9 | itérateur public Iterator () | Renvoie l'itérateur de la collection. |
| dix | Public Object () toArray () | Convertissez la collection en tableau. |
| Onze | public T () toArray (T () a) | Convertissez la collection en un tableau avec un type de retour spécifié. |
| 12 | public booléen isEmpty () | Renvoie si la collection est vide ou non. |
| 13 | public boolean contient (élément Object) | Vérifiez si une collection contient l'élément donné (opération de recherche). |
| 14 | public booleancontainsAll (Collectionc) | Vérifiez si la collection contient la collection c spécifiée à l'intérieur. |
| quinze | spliterator par défaut () | Renvoie le séparateur sur une collection spécifiée. |
| 16 | public booleanequals (élément Object) | Utilisé pour faire correspondre deux collections. |
| 17 | par défaut Stream parallelStream () | Renvoie un flux parallèle en utilisant la collection comme source. |
| 18 | Streamstream par défaut () | Renvoie un flux séquentiel en utilisant la collection comme source. |
| 19 | public int hashCode () | Renvoie le hashcode numérique de la collection. |
Interface itérable
L'interface Iterable est également l'interface de base du framework de collecte. L'interface Collection qui est l'interface parente de toutes les autres classes étend l'interface Iterable. Par conséquent, toutes les classes implémentent une interface de collection ainsi qu'une interface Iterable.
L'interface Iterable n'a qu'une seule méthode iterator () qui renvoie l'itérateur () que vous pouvez utiliser pour itérer sur les éléments de type T.
Iterator iterator ()Interface d'itérateur
L'interface Iterator offre la possibilité de parcourir les éléments dans une direction directe.
Voici les méthodes prises en charge par cette interface.
| Ne pas | Prototype de méthode | Description |
|---|---|---|
| 1 | Objet public suivant () | Retourne d'abord l'élément, puis déplace le curseur pour qu'il pointe vers l'élément suivant. |
| deux | public booléen hasNext () | Vérifie si l'itérateur a plus d'éléments. |
| 3 | public void remove () | Supprime l'élément renvoyé par l'itérateur à la fin. |
Interface de liste
L'interface de liste hérite de l'interface de collection. L'interface de liste contient les structures de données utilisées pour stocker des données ordonnées ou une collection d'objets. Ces structures de données sont de type liste. Ces structures de données implémentant l'interface de liste peuvent avoir ou non des valeurs en double.
L'interface de liste contient les méthodes utilisées pour accéder, insérer ou supprimer des éléments des objets de liste.
Les différentes classes qui implémentent l'interface List sont les suivantes:
comment ouvrir le fichier mkv sous windows
- Liste des tableaux
- LinkedList
- Vecteur
- Empiler
Nous discuterons brièvement de chacune de ces classes. Nos sujets suivants auront une discussion détaillée sur chacune des classes de cadre de collection.
# 1) ArrayList
ArrayList est l'implémentation la plus simple de l'interface List. ArrayList préserve l'ordre d'insertion et il n'est pas synchronisé.
La définition générale de la structure de données ArrayList (Collection) est la suivante:
List list1= new ArrayList ();Une fois la liste définie, vous pouvez utiliser la méthode «add» pour ajouter des éléments. Notez qu'en interne, ArrayList utilisait un mécanisme de tableau dynamique.
Consultez les exemples suivants qui créent une collection de couleurs ArrayList.
import java.util.*; class Main { public static void main(String args()) { //Creating arraylist of String objects ArrayList color_list=new ArrayList(); //populate the arraylist with add method color_list.add('Red'); color_list.add('Green'); color_list.add('Blue'); color_list.add('Cyan'); color_list.add('Magenta'); color_list.add('Yellow'); //Traverse the list through Iterator Iterator itr=color_list.iterator(); System.out.println('The contents of the arraylist are:'); while(itr.hasNext()){ System.out.println(itr.next()); } } } Production:
Le programme ci-dessus montre la démonstration de la collection ArrayList. Nous ajoutons des valeurs de couleur à la collection, puis parcourons la collection pour afficher les valeurs individuelles de la collection à l'aide d'un itérateur.
# 2) LinkedList
La collection LinkedList utilise en interne un mécanisme de liste à double chaînage pour stocker des éléments. Il peut contenir des éléments en double. Les opérations de collecte LinkedList sont plus rapides car le déplacement des éléments n'est pas nécessaire.
La définition générale de la création d'une liste liée est la suivante:
List list2 = new LinkedList ();Le programme suivant montre la liste chaînée collection de noms de numéros .
import java.util.*; class Main { public static void main(String args()) { //linked list of String objects LinkedList linkedlist_num=new LinkedList(); linkedlist_num.add('one'); linkedlist_num.add('two'); linkedlist_num.add('three'); linkedlist_num.add('four'); linkedlist_num.add('five'); //iterate over the linked list to display contents Iterator itr=linkedlist_num.iterator(); System.out.println('The contents of the linked list are:'); while(itr.hasNext()) { System.out.println(itr.next()); } } } Production:
Ainsi, nous créons une liste chaînée, puis y ajoutons des éléments en utilisant la méthode «add». Puis à l'aide d'un itérateur, nous parcourons la liste chaînée et affichons chaque élément.
# 3) Vecteur
Vector est similaire à ArrayList et utilise un tableau dynamique pour stocker les éléments comme ArrayList. Mais vector prend en charge de nombreuses méthodes indépendantes en dehors de la collection, ce qui en fait un meilleur choix pour être une collection préférée.
La définition générale de la collection de vecteurs est:
List list3 = new Vector();Notez que bien que vector et ArrayList utilisent le même mécanisme que les tableaux dynamiques, les éléments vectoriels sont synchronisés.
Le programme Java donné ci-dessous montre l'utilisation de vecteurs dans le framework de collecte .
import java.util.*; public class Main { public static void main(String args()) { Vector subject_vector=new Vector(); subject_vector.add('English'); subject_vector.add('Hindi'); subject_vector.add('Maths'); subject_vector.add('Science'); Iterator itr=subject_vector.iterator(); System.out.println('Vector contents:'); while(itr.hasNext()) { System.out.println(itr.next()); } } } Production:
Dans ce programme, nous avons défini une collection vectorielle constituée de sujets. Nous ajoutons divers sujets, puis utilisons un itérateur pour générer les éléments.
# 4) Pile
La structure de données de pile implémente la méthode LIFO (last-in-first-out) d'insertion d'éléments. La pile est une sous-classe du vecteur de classe (reportez-vous au diagramme de hiérarchie des collections ci-dessus). Outre ses propres méthodes, la collection de piles prend également en charge les méthodes de collecte de vecteurs.
La définition générale de la collection Stack est:
List list4 = new Stack();Le programme suivant implémente la collection Stack .
import java.util.*; public class Main { public static void main(String args()) { Stack even_stack = new Stack (); even_stack.push(2); even_stack.push(4); even_stack.push(6); even_stack.push(8); even_stack.push(10); System.out.println('The element removed from stack: ' + even_stack.pop()); Iterator itr=even_stack.iterator(); System.out.println('The contents of the stack are:'); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } } Production:
Comme vous pouvez le voir dans l'implémentation ci-dessus, les nouveaux éléments sont ajoutés à la pile en utilisant le 'pousser' opération. La pile a un point d’entrée unique appelé «Haut de la pile» et les éléments sont poussés sur la pile en haut. Ainsi, le dernier élément ajouté se trouve en haut de la pile.
Tout comme l'ajout, les éléments sont également supprimés d'une extrémité, c'est-à-dire du haut de la pile. Pour supprimer des éléments, une opération «pop» est utilisée. Ainsi, si vous appelez pop (), l'élément en haut de la pile sera supprimé.
Dans la sortie ci-dessus, nous insérons l'élément 2, 4, 6,8,10 puis appelons pop () pour que 10 soit supprimé.
Interface de file d'attente
Les collections dérivées de l'interface de file d'attente suivent l'ordre du premier entré, premier sorti (FIFO). Les éléments sont insérés à une extrémité et sont retirés de l'autre extrémité. Par conséquent, l'élément entré en premier se trouve être l'élément qui est supprimé en premier.
Vous trouverez ci-dessous les collections qui prennent en charge l'interface de requête.
- File d'attente de priorité
- et interface
- ArrayDeque
Discutons brièvement de chacun de ces éléments.
# 1) PriorityQueue
Dans la collection PriorityQueue, les éléments stockés sont traités en fonction de leurs priorités. Vous ne pouvez pas stocker de valeurs nulles dans la file d'attente prioritaire.
La définition générale de la file d'attente prioritaire est la suivante:
Queue q1 = new PriorityQueue();Le programme ci-dessous implémente la file d'attente prioritaire.
import java.util.*; public class Main { public static void main(String args()) { PriorityQueue color_queue=new PriorityQueue(); color_queue.add('red'); color_queue.add('green'); color_queue.add('blue'); color_queue.add('cyan'); color_queue.add('magenta'); color_queue.add('yellow'); System.out.println('Priority Queue elements:'); System.out.println('head:'+color_queue.peek()); System.out.println('Other elements in Priority Queue:'); Iterator itr=color_queue.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } System.out.println('
'); color_queue.remove(); System.out.println('After removing element, new head:'+color_queue.element()); System.out.println('
'); color_queue.poll(); System.out.println('After removing another element, Priority Queue :'); Iterator itr2=color_queue.iterator(); while(itr2.hasNext()) { System.out.print(itr2.next() + ' '); } } } Production:
Une fois de plus, nous utilisons les couleurs comme éléments de la file d'attente prioritaire. Dans le programme ci-dessus, nous avons utilisé les méthodes add et remove pour ajouter des éléments à la file d'attente et supprimer un élément respectivement. Nous utilisons la méthode peek () qui renvoie un élément vers lequel il pointe dans la file d'attente prioritaire.
Enfin à l'aide d'un itérateur, les éléments de la file de priorité sont affichés.
# 2) interface tactile
Deque ou une «file d'attente à deux extrémités» est une structure de données qui vous permet d'ajouter et de supprimer les éléments des deux extrémités. L'interface deque dans le framework de collecte Java qui étend l'interface Queue.
Il fournit les fonctionnalités de deque et possède une classe 'ArrayDeque' qui en hérite.
# 3) ArrayDeque
ArrayDeque implémente l'interface deque.
La définition générale de ArrayDeque est la suivante:
Deque d = new ArrayDeque();ArrayDeque vous permet d'utiliser les fonctionnalités de Deque. Contrairement à d'autres collections comme ArrayList ou stack, ArrayDeque n'a aucune restriction sur sa capacité.
L'exemple suivant montre l'implémentation d'ArrayDeque.
import java.util.*; public class Main { public static void main(String() args) { //Creating Deque and adding elements Deque deque = new ArrayDeque (); deque.add(10); deque.add(20); deque.add(30); System.out.println('Deque Elements:'); //Traversing elements for (Integer num : deque) { System.out.println(num); } } } Production:
Dans le programme ci-dessus, nous définissons une collection ArrayDeque de type integer et y ajoutons des éléments entiers à l'aide de la méthode add. La collection est ensuite parcourue à l'aide de la construction for.
Définir l'interface
L'interface set fait partie du package java.util et s'étend de l'interface de collection. Set est une structure qui n'autorise pas la collection à avoir des valeurs en double et également plus d'une valeur nulle.
Les classes suivantes implémentent l'interface set.
- HashSet
- LinkedHashSet
- TreeSet
# 1) HashSet
La collection HashSet qui implémente l'interface Set contient des valeurs distinctes. Cette collection utilise la technique de hachage pour stocker les éléments et utilise la table de hachage pour stocker les éléments.
T La définition générale de la collection HashSet est présentée ci-dessous.
comment ajouter maven à l'éclipse
Set s1 = new HashSet();Nous avons donné l'implémentation HashSet dans le programme suivant.
import java.util.*; public class Main { public static void main(String args()) { //Create HashSet set_subjects HashSet set_subjects=new HashSet(); System.out.println('Elements in the given hashsetset_subjects are:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('French'); //Traverse the hashset Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } } Production:
Dans le programme ci-dessus, nous créons une collection HashSet de sujets, puis la parcourons à l'aide d'un itérateur pour afficher les éléments de la collection.
# 2) LinkedHashSet
LinkedHashSet implémente une interface d'ensemble et étend HashSet (reportez-vous à la hiérarchie des collections). LinkedHashSet est la représentation en liste chaînée de l'interface Set. LinkedHashSet contient des éléments uniques mais autorise les valeurs nulles.
La définition générale de LinkedHashSet est donnée ci-dessous.
Set s2 = new LinkedHashSet();L'implémentation de LinkedHashSet est donnée ci-dessous.
import java.util.*; public class Main { public static void main(String args()) { LinkedHashSet set_subjects=new LinkedHashSet(); System.out.println('Elements in the LinkedHashSet set_subjects:'); set_subjects.add('Maths'); set_subjects.add('Computers'); set_subjects.add('English'); set_subjects.add('Sanskrit'); Iterator itr=set_subjects.iterator(); while(itr.hasNext()) { System.out.println(itr.next()); } } } Production:
Une fois de plus, nous utilisons les titres de livres pour créer Linkedhashset. Comme vous pouvez le voir dans la sortie, l'ordre d'ajout est maintenu par linkedHashSet.
Interface SortedSet
L'interface SortedSet permet un classement complet des éléments. Il contient des méthodes qui fournissent un ordre naturel des éléments. Les éléments de la collection qui implémentent l'interface SortedSet sont classés par ordre croissant.
La classe TreeSet est l'un des exemples qui implémente l'interface SortedSet.
Arbres
La définition générale de Treeset est la suivante:
Set s3 = new TreeSet();TreeSet implémente l'interface SortedSet et contient des éléments uniques. Le stockage et la récupération sont assez rapides, puis les éléments sont disposés par ordre croissant.
import java.util.*; public class Main{ public static void main(String args()) { //create a treeset of integers TreeSet set_oddnums=new TreeSet (); set_oddnums.add(1); set_oddnums.add(3); set_oddnums.add(5); set_oddnums.add(7); set_oddnums.add(9); System.out.println('Elements in TreeSet are:'); //traverse the treeset using iterator Iterator itr=set_oddnums.iterator(); while(itr.hasNext()) { System.out.print(itr.next() + ' '); } } } Production:
Dans le programme ci-dessus, nous avons créé et ajouté des nombres impairs à la collection en utilisant des méthodes add. Ensuite, à l'aide d'un itérateur, nous sortons les éléments de la collection.
Avantages de Java Collections Framework
- Programmation réduite: Le framework Collections est livré avec toutes les interfaces et classes contenant les méthodes qui peuvent permettre aux programmeurs d'écrire un programme efficace. De cette façon, le programmeur n'a pas besoin de se concentrer sur trop de programmation.
- Méthodes et API cohérentes: Toutes les classes ont des méthodes communes qui agissent sur les données. Ces API sont cohérentes dans toutes les classes et le programmeur n'a pas à s'inquiéter d'avoir trop de méthodes différentes pour chaque classe.
- Augmentez la vitesse et la précision: Vous pouvez écrire des programmes très efficaces en utilisant un framework de collecte et également des programmes plus rapides et précis car le framework de collecte fournit toutes les fonctionnalités pour implémenter les structures de données et les collections.
- Facilite la réutilisation des logiciels: Les structures de données et les algorithmes du framework de collecte Java sont réutilisables.
- Interopérabilité entre les API non liées: Les API de collecte permettent l'interopérabilité même entre des API non liées.
- Moins d'efforts pour concevoir de nouvelles API: Les programmeurs peuvent utiliser les API de collecte standard et concevoir de nouvelles API basées sur cela. Ils n'ont pas à lutter pour écrire de nouvelles API complètes.
Questions fréquemment posées
# 1) Quelle est l'utilisation d'un framework de collecte en Java?
Répondre: Le framework de collecte offre des algorithmes, des interfaces et des classes pré-emballés qui permettent aux programmeurs d'écrire des programmes très efficaces capables de stocker et de traiter des données.
# 2) Pourquoi Collection est-il un framework?
Répondre: Un framework est une collection réutilisable de classes, d'interfaces et d'algorithmes. Le cadre de collecte est également une collection réutilisable de classes de structure de données et d'algorithmes fonctionnant sur ces classes.
# 3) Qu'est-ce que l'API Java Collections en Java?
Répondre: L'API des collections Java fournit des interfaces et des classes qui peuvent être étendues et implémentées afin d'utiliser des structures de données qui ne sont que des collections.
# 4) Quelle est la différence entre la collection et les collections en Java?
Répondre: La collection est une interface de base dans le cadre de la collection tandis que «collections» est une classe. Les deux font partie du package java.util.
**** Plus de détails et d'exemples de Java Collections Framework: ****
Comparaison entre List, Set et Queue:
| Lister | Ensemble | File d'attente |
|---|---|---|
| L'ordre d'insertion est maintenu | L'ordre d'insertion n'est pas conservé dans le jeu de hachage | L'ordre d'insertion est conservé. |
| Peut contenir des éléments en double | Ne peut pas contenir d'éléments en double | Peut contenir des éléments en double. |
| L'insertion et la suppression d'un tableau peuvent être effectuées pour n'importe quel index. | Supprimez l'élément spécifié. | Seul le dernier élément inséré peut être sorti. De plus, l'insertion d'éléments se produit à la fin. |
Classe de liste de tableaux
Dans Array, l'allocation de mémoire est fixe. Mais dans ArrayList, la mémoire peut être allouée dynamiquement. Cette classe ArrayList gère l'ordre d'insertion et vous pouvez insérer des éléments en double.
Programme de démonstration pour Array List:
public class ArrayListDemo { public static void main(String() args) { ArrayList li = new ArrayList (); li.add(1); li.add(2); li.add(3); li.remove(0); for (Integer temp : li) { System.out.println(temp); } System.out.println('=========='); ArrayList l = new ArrayList(); l.add('text1'); l.add('text2'); l.add('text3'); for (String temp : l) { System.out.println(temp); } System.out.println('=========='); ArrayList al=new ArrayList(); al.add(1); al.add(2); al.forEach((a)->;System.out.println(a)); } } 
Classe LinkedList
La structure de données de la liste liée contient des nœuds et ce nœud contiendra deux parties:
- Données
- Référence à l'élément suivant
Le premier nœud n'est pas un nœud séparé. Il ne contient que la référence et s'appelle une tête. Le dernier nœud est nul.
Programme de démonstration:
public class LinkedListDemo { public static void main(String() args) { LinkedList list =new LinkedList(); list.add(22); list.add(44); list.add(46); list.add(46); list.add(46); for(Integer temp:list) { System.out.println(temp); } Iterator it =list.iterator(); while(it.hasNext()) { System.out.println(it.next()); } System.out.println('=========='); for (int i=0;i 
File d'attente
Une file d'attente est la structure de données premier entré premier sorti (FIFO). Si vous appelez la méthode remove, le premier élément inséré sera toujours supprimé de la file d'attente. Ainsi, la file d'attente est utilisée dans une application en temps réel où les données doivent être récupérées dans l'ordre inséré.
Exemple de programme:
public class QueueDemo { public static void main(String() args) { PriorityQueue pq=new PriorityQueue(); pq.add(1); pq.add(2); pq.add(3); pq.add(4); pq.add(5); pq.add(6); pq.add(7); for(int temp : pq) { System.out.println(temp); } pq.remove(); System.out.println('queue after removing a element'); System.out.println(pq); } } 
Ensemble
Une collection d'ensemble n'autorisera pas les éléments en double. Vous pouvez utiliser une structure de données définie, lorsque vous souhaitez traiter la collecte de données sans duplication et lorsqu'il n'est pas nécessaire de maintenir l'ordre d'insertion.
Programme de démonstration:
public class demohashset { public static void main (String() args){ HashSet hs=new HashSet(); hs.add(23); hs.add(24); hs.add(25); hs.add(26); hs.add(27); hs.add(28); hs.add(293); hs.add(203); hs.add(263); hs.add(243); hs.add(243); (int temp:hs) { System.out.println(temp); } hs.remove(24); hs.remove(23); System.out.println('==============='); System.out.println('after removing a element ::::'); System.out.println('==============='); hs.forEach((temp)->System.out.println(temp)); ; } } 
Interface MAP
- Lorsque vous souhaitez traiter la collecte d'éléments avec la paire clé et valeur, vous pouvez utiliser la structure de données de mappage car la mappe est un objet qui peut mapper des clés sur des valeurs.
- Une carte ne peut pas contenir de clés en double.
- Les implémentations importantes de map sont HashMap, Treemap, LinkedHashMap, HashTable.
Différence entre HashMap, Treemap, LinkedHashMap et HashTable:
HashMap TreeMap LinkedHashmap HashTable Les clés et valeurs nulles sont autorisées Seules les valeurs nulles sont autorisées. Clés et valeurs nulles autorisées. Il n'autorise pas les clés et valeurs nulles. Non synchronisé Non synchronisé Non synchronisé synchronisé Il n'y a aucune garantie de maintenir l'ordre dans l'itération Le tri sera effectué en fonction de l'ordre naturel. L'ordre d'insertion sera maintenu L'ordre d'insertion n'est pas maintenu.
Programme de démonstration:
public class HashMapDemo { public static void main(String() args) { HashMap m=new HashMap(); m.put(1, 'one'); m.put(2, 'two'); m.put(3, 'three'); m.put(4, 'four'); m.put(null, 'one'); m.put(null, null); System.out.println(m); TreeMap tm =new TreeMap(); tm.put('R', 'red'); tm.put('B', null); tm.put('G', 'green'); System.out.println(tm); Hashtable ht =new Hashtable(); ht.put(1, 'one'); ht.put(2, 'two'); ht.put(3, 'three'); ht.put(4, 'four'); System.out.println(ht); } } 
Points clés à noter:
- Les interfaces List, Queue, Set étendent l'interface de collection et cette interface de collection a des méthodes communes comme ajouter, supprimer, etc.
- L'ordre d'insertion est conservé dans la liste et un ensemble ne peut pas contenir d'éléments en double. La file d'attente est la structure de données First in First Out.
- La carte contiendra des paires clé et valeur. HashMap, Treemap, Hashtable, Linked HashMap sont l'implémentation importante de l'interface de la carte.
Conclusion
Ce didacticiel nous a donné une introduction à Java Collections Framework. Nous avons brièvement abordé toutes les classes et interfaces qui font partie du framework de collection Java.
Dans nos tutoriels ultérieurs de cette série, nous apprendrons en détail chacune de ces classes et interfaces.
Vous pouvez en savoir plus sur Reflections in JAVA dans notre prochain tutoriel !!!
Tutoriel PREV | Tutoriel SUIVANT
lecture recommandée
- Tutoriel de réflexion Java avec des exemples
- Tutoriels Eclipse détaillés pour les débutants
- Tutoriel Java SWING: Conteneur, composants et gestion des événements
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- Modificateurs d'accès en Java - Tutoriel avec des exemples
- Tutoriel Java String with String Buffer et String Builder
- Introduction au langage de programmation Java - Tutoriel vidéo
- Tutoriel Cucumber Selenium: Intégration Cucumber Java Selenium WebDriver
