1. Cadre de collecte Java
2. Hiérarchie du cadre de collecte
3. Interface de collecte
4. Interface de l'itérateur

Le Collection en Java est un framework qui fournit une architecture pour stocker et manipuler le groupe d'objets.

Les collections Java peuvent réaliser toutes les opérations que vous effectuez sur des données telles que la recherche, le tri, l'insertion, la manipulation et la suppression.

Java Collection signifie une seule unité d’objets. Le framework Java Collection fournit de nombreuses interfaces (Set, List, Queue, Deque) et classes ( Liste des tableaux , Vecteur, Liste liée , File d'attente de priorité , HashSet, LinkedHashSet, TreeSet).

Qu'est-ce que la collection en Java

Une collection représente une seule unité d’objets, c’est-à-dire un groupe.

Qu'est-ce qu'un framework en Java

• Il fournit une architecture prête à l’emploi.
• Il représente un ensemble de classes et d'interfaces.
• C'est facultatif.

Qu'est-ce que le cadre de collection

Le framework Collection représente une architecture unifiée pour stocker et manipuler un groupe d’objets. Il a:

1. Interfaces et ses implémentations, c'est-à-dire les classes
2. Algorithme

• Quelles sont les deux manières d’itérer les éléments d’une collection ?
• Quelle est la différence entre les classes ArrayList et LinkedList dans le cadre de collection ?
• Quelle est la différence entre les classes ArrayList et Vector dans le framework de collection ?
• Quelle est la différence entre les classes HashSet et HashMap dans le cadre de collection ?
• Quelle est la différence entre les classes HashMap et Hashtable ?
• Quelle est la différence entre les interfaces Iterator et Enumeration dans le cadre de collection ?
• Comment trier les éléments d’un objet ? Quelle est la différence entre les interfaces Comparable et Comparateur ?
• Que fait la méthode hashcode() ?
• Quelle est la différence entre les collections Java et les collections Java ?

Hiérarchie du cadre de collecte

Voyons la hiérarchie du framework Collection. Le java.util le paquet contient tous les Des classes et interfaces pour le framework Collection.

Interface des méthodes de collecte

Il existe de nombreuses méthodes déclarées dans l'interface Collection. Ils sont les suivants :

Interface de l'itérateur

Méthodes de l'interface Itérateur

Il n'y a que trois méthodes dans l'interface Iterator. Ils sont:

Interface itérable

L'interface Iterable est l'interface racine de toutes les classes de collection. L'interface Collection étend l'interface Iterable et donc toutes les sous-classes de l'interface Collection implémentent également l'interface Iterable.

Il ne contient qu'une seule méthode abstraite. c'est à dire.,

 Iterator iterator() 

Il renvoie l'itérateur sur les éléments de type T.

les meilleures voitures du monde

Interface de collecte

L'interface Collection est l'interface qui est implémentée par toutes les classes du framework de collection. Il déclare les méthodes que chaque collection aura. En d’autres termes, nous pouvons dire que l’interface Collection constitue la base sur laquelle dépend le cadre de collection.

Certaines des méthodes de l'interface Collection sont Boolean add (Object obj), Boolean addAll (Collection c), void clear(), etc. qui sont implémentées par toutes les sous-classes de l'interface Collection.

Interface de liste

L’interface List est l’interface enfant de l’interface Collection. Il inhibe une structure de données de type liste dans laquelle nous pouvons stocker la collection ordonnée d'objets. Il peut avoir des valeurs en double.

L'interface de liste est implémentée par les classes ArrayList, LinkedList, Vector et Stack.

Pour instancier l'interface List, il faut utiliser :

 List list1= new ArrayList(); List list2 = new LinkedList(); List list3 = new Vector(); List list4 = new Stack(); 

Il existe différentes méthodes dans l'interface List qui peuvent être utilisées pour insérer, supprimer et accéder aux éléments de la liste.

Les classes qui implémentent l'interface List sont indiquées ci-dessous.

Liste des tableaux

La classe ArrayList implémente l'interface List. Il utilise un tableau dynamique pour stocker l'élément en double de différents types de données. La classe ArrayList conserve l'ordre d'insertion et n'est pas synchronisée. Les éléments stockés dans la classe ArrayList sont accessibles de manière aléatoire. Considérez l'exemple suivant.

 import java.util.*; class TestJavaCollection1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Ravi');//Adding object in arraylist list.add('Vijay'); list.add('Ravi'); list.add('Ajay'); //Traversing list through Iterator Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Ravi Vijay Ravi Ajay 

Liste liée

LinkedList implémente l'interface Collection. Il utilise une liste doublement chaînée en interne pour stocker les éléments. Il peut stocker les éléments en double. Il conserve l'ordre d'insertion et n'est pas synchronisé. Dans LinkedList, la manipulation est rapide car aucun décalage n'est nécessaire.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection2{ public static void main(String args[]){ LinkedList al=new LinkedList(); al.add('Ravi'); al.add('Vijay'); al.add('Ravi'); al.add('Ajay'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Ravi Vijay Ravi Ajay 

Vecteur

Vector utilise un tableau dynamique pour stocker les éléments de données. C'est similaire à ArrayList. Cependant, il est synchronisé et contient de nombreuses méthodes qui ne font pas partie du framework Collection.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection3{ public static void main(String args[]){ Vector v=new Vector(); v.add('Ayush'); v.add('Amit'); v.add('Ashish'); v.add('Garima'); Iterator itr=v.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Ayush Amit Ashish Garima 

Empiler

La pile est la sous-classe de Vector. Il implémente la structure de données dernier entré, premier sorti, c'est-à-dire Stack. La pile contient toutes les méthodes de la classe Vector et fournit également ses méthodes comme boolean push(), boolean peek(), boolean push(object o), qui définissent ses propriétés.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection4{ public static void main(String args[]){ Stack stack = new Stack(); stack.push('Ayush'); stack.push('Garvit'); stack.push('Amit'); stack.push('Ashish'); stack.push('Garima'); stack.pop(); Iterator itr=stack.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Ayush Garvit Amit Ashish 

Interface de file d'attente

L'interface de file d'attente maintient l'ordre du premier entré, premier sorti. Il peut être défini comme une liste ordonnée utilisée pour contenir les éléments sur le point d'être traités. Il existe différentes classes comme PriorityQueue, Deque et ArrayDeque qui implémentent l'interface Queue.

L'interface de file d'attente peut être instanciée comme :

 Queue q1 = new PriorityQueue(); Queue q2 = new ArrayDeque(); 

Il existe différentes classes qui implémentent l'interface Queue, certaines d'entre elles sont indiquées ci-dessous.

File d'attente de priorité

La classe PriorityQueue implémente l'interface Queue. Il contient les éléments ou objets qui doivent être traités selon leurs priorités. PriorityQueue n'autorise pas le stockage de valeurs nulles dans la file d'attente.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection5{ public static void main(String args[]){ PriorityQueue queue=new PriorityQueue(); queue.add('Amit Sharma'); queue.add('Vijay Raj'); queue.add('JaiShankar'); queue.add('Raj'); System.out.println('head:'+queue.element()); System.out.println('head:'+queue.peek()); System.out.println('iterating the queue elements:'); Iterator itr=queue.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } queue.remove(); queue.poll(); System.out.println('after removing two elements:'); Iterator itr2=queue.iterator(); while(itr2.hasNext()){ System.out.println(itr2.next()); } } } 

Sortir:

 head:Amit Sharma head:Amit Sharma iterating the queue elements: Amit Sharma Raj JaiShankar Vijay Raj after removing two elements: Raj Vijay Raj 

Et l'interface

L'interface Deque étend l'interface Queue. Dans Deque, nous pouvons supprimer et ajouter des éléments des deux côtés. Deque signifie une file d'attente à double extrémité qui nous permet d'effectuer les opérations aux deux extrémités.

Deque peut être instancié comme :

 Deque d = new ArrayDeque(); 

TableauDeque

La classe ArrayDeque implémente l'interface Deque. Cela nous facilite l’utilisation du Deque. Contrairement à la file d’attente, nous pouvons ajouter ou supprimer des éléments aux deux extrémités.

ArrayDeque est plus rapide qu'ArrayList et Stack et n'a aucune restriction de capacité.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection6{ public static void main(String[] args) { //Creating Deque and adding elements Deque deque = new ArrayDeque(); deque.add('Gautam'); deque.add('Karan'); deque.add('Ajay'); //Traversing elements for (String str : deque) { System.out.println(str); } } } 

Sortir:

 Gautam Karan Ajay 

Définir l'interface

Set Interface en Java est présent dans le package java.util. Il étend l'interface Collection. Il représente l'ensemble non ordonné d'éléments qui ne nous permet pas de stocker les éléments en double. Nous pouvons stocker au plus une valeur nulle dans Set. Set est implémenté par HashSet, LinkedHashSet et TreeSet.

Set peut être instancié comme :

 Set s1 = new HashSet(); Set s2 = new LinkedHashSet(); Set s3 = new TreeSet(); 

Jeu de hachage

La classe HashSet implémente Set Interface. Il représente la collection qui utilise une table de hachage pour le stockage. Le hachage est utilisé pour stocker les éléments dans le HashSet. Il contient des objets uniques.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection7{ public static void main(String args[]){ //Creating HashSet and adding elements HashSet set=new HashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //Traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Vijay Ravi Ajay 

LinkedHashSet

La classe LinkedHashSet représente l’implémentation LinkedList de Set Interface. Il étend la classe HashSet et implémente l'interface Set. Comme HashSet, il contient également des éléments uniques. Il maintient l'ordre d'insertion et autorise les éléments nuls.

Considérez l'exemple suivant.

 import java.util.*; public class TestJavaCollection8{ public static void main(String args[]){ LinkedHashSet set=new LinkedHashSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Ravi Vijay Ajay 

Interface SortedSet

SortedSet est l'alternative de l'interface Set qui fournit un classement total de ses éléments. Les éléments du SortedSet sont classés par ordre croissant (ascendant). Le SortedSet fournit les méthodes supplémentaires qui inhibent l’ordre naturel des éléments.

Le SortedSet peut être instancié comme :

 SortedSet set = new TreeSet(); 

Ensemble d'arbres

La classe Java TreeSet implémente l'interface Set qui utilise une arborescence pour le stockage. Comme HashSet, TreeSet contient également des éléments uniques. Cependant, le temps d’accès et de récupération de TreeSet est assez rapide. Les éléments de TreeSet stockés par ordre croissant.

Prenons l'exemple suivant :

 import java.util.*; public class TestJavaCollection9{ public static void main(String args[]){ //Creating and adding elements TreeSet set=new TreeSet(); set.add('Ravi'); set.add('Vijay'); set.add('Ravi'); set.add('Ajay'); //traversing elements Iterator itr=set.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 Ajay Ravi Vijay 

1. Classe ArrayList
2. Classe LinkedList
3. Interface de liste
4. Classe HashSet
5. Classe LinkedHashSet
6. Classe TreeSet
7. Classe PriorityQueue
8. Interface cartographique
9. Classe HashMap
10. Classe LinkedHashMap
11. Classe TreeMap
12. Classe de table de hachage
13. Tri
14. Interface comparable
15. Interface du comparateur
16. Classe de propriétés en Java