Collections en Java

Qu’est-ce que la collection en Java ?

Une collection en Java est représentée comme un conteneur qui regroupe tous les éléments en une seule unité. Par exemple , un dossier de courrier (groupe d'e-mails), un annuaire téléphonique (mappage de noms sur des numéros de téléphone).

Qu'est-ce qu'un cadre ?

Un framework est une base ou une mise en page de base sur laquelle vous commencez à travailler en utilisant les différentes classes et interfaces fournies. Par exemple , Laravel est l’un des frameworks PHP les plus connus qui fournit un squelette de base pour votre application.

Qu’est-ce que le framework de collections en Java ?

Tous les objets sont regroupés en un seul objet avec une architecture qui représente et fournit différentes méthodes de manipulation des collections. Ainsi, le framework Collections en Java fournit différentes structures de données déjà implémentées pour stocker les données et les méthodes, pour les manipuler avec des fonctionnalités telles que le tri, la recherche, la suppression et l'insertion . Par exemple , vous souhaitez mettre en œuvre un système pour une entreprise aléatoire afin d'améliorer le service offert à ses clients, sur la base du premier arrivé, premier servi. Ceci est également connu sous le nom d’implémentation FIFO (premier entré, premier sorti). Nous devons maintenant implémenter cette structure de données, puis l'utiliser pour atteindre notre objectif. Le framework Collections nous fournit une interface de file d'attente qu'il nous suffit d'importer plutôt que d'implémenter, puis de l'utiliser, et nous avons terminé. Implémentation : Vous pouvez importer toutes les collections en utilisant la ligne suivante :

import java.util.*;

Si vous souhaitez importer une collection spécifique, utilisez le nom exact du package, tel que :

import java.util.LinkedList;

Avantages du framework de collections en Java

Il présente les avantages suivants.

1. Déjà mis en œuvre (gain de temps).
2. Efficacité des performances (rapidité et qualité).
3. Réduit les efforts d’apprentissage et d’utilisation de nouvelles API.

Quelle est la hiérarchie du cadre de collecte ?

Voyons maintenant la hiérarchie des collections mais d'abord, nous devons connaître les composants essentiels de ce framework.

1. Interfaces
2. Cours (mise en œuvre)
3. Algorithmes

Hiérarchie du cadre de collecte

Pour votre compréhension:

1. Collection, Set, Queue et List sont tous des interfaces. Set, Queue et List sont étendus par l'interface Collection.
2. PriorityQueue, HashSet, LinkedList et Stack sont tous des classes ou l'implémentation de ces interfaces.
3. Il n’est pas obligatoire qu’une classe implémente une seule interface. LinkedList implémente également l'interface Deque, par exemple.

Types de collections

Le framework de collections Java contient de nombreux types de collections pour réduire nos efforts. Voici une liste de quelques-unes des collections :

1. Classe ArrayList
2. Classe LinkedList
3. Interface de liste
4. Définir l'interface
5. Interface de file d'attente
6. Interface cartographique
7. Classe PriorityQueue
8. Classe HashMap
9. Interface comparable
10. Classe LinkedHashMap
11. Classe TreeMap
12. Table de hachage

Interfaces de collecte

Ici, nous discuterons de quelques interfaces de collection courantes, puis de certaines méthodes implémentées par les classes.

Interface de collecte

Il s'agit d'une base de base pour le framework Collections car il fournit toutes les méthodes nécessaires à la mise en œuvre. La Map est la seule structure de données qui ne l'implémente pas mais les autres implémentent toutes ses méthodes. Cette interface dispose de méthodes permettant de connaître la taille de la collection et si un objet existe dans la collection, en ajoutant ou en supprimant des objets de la collection.

Interface itérable

Il s'agit de l'interface racine du framework Collections car elle est étendue par l'interface Collection qui est implémentée par toutes les classes. Il renvoie un itérateur pour que la collection spécifique puisse la parcourir.

Interface de file d'attente

La file d'attente est utilisée pour contenir les éléments mais ils ne peuvent pas être traités. Mettant en œuvre les opérations de collecte de base, il fournit également des méthodes d'insertion et d'extraction supplémentaires.

Définir l'interface

L'ensemble est utilisé pour contenir des éléments uniques. Il ne contient jamais d'éléments en double et modélise l'abstraction mathématique des ensembles pour représenter les ensembles tels que les processus exécutés sur une machine.

Interface de liste

La liste est une collection ordonnée, parfois appelée séquence, qui peut contenir des éléments en double. Il permet à l'utilisateur de contrôler la mise à jour ou la suppression d'un élément spécifique, en insérant un élément à un point spécifique en utilisant sa valeur d'index entière. LinkedList et ArrayList sont des classes d'implémentation de l'interface List.

Interface Deque

Deque signifie file d'attente à double extrémité, ce qui signifie que nous pouvons effectuer des opérations aux deux extrémités. Nous pouvons insérer et supprimer des éléments des deux extrémités. L'interface Deque étend l'interface de file d'attente. ArrayDeque et LinkedList implémentent tous deux l'interface Deque. Il fournit des méthodes d'insertion, de suppression et d'examen de l'instance des deux côtés.

Interface cartographique

L'interface Map fait également partie du framework Collections mais elle n'étend pas l'interface Collection. Il est utilisé pour stocker des paires clé-valeur. Ses principales implémentations sont HashMap, TreeMap et LinkesHashMap qui sont similaires à certains égards à HashSet, TreeSet et LinkedHashSet. Il contient toujours des clés uniques mais les valeurs peuvent être dupliquées. Ceci est utile lorsque vous devez ajouter, supprimer ou rechercher un élément en fonction d'une clé. Il nous fournit des méthodes de base telles que put , get , remove , size , empty , etc.

Méthodes courantes de ces interfaces

Nous allons maintenant examiner quelques méthodes courantes fournies pour l'implémentation de différentes classes dans ce framework, à l'exception de l'interface Map.

Cours de collecte

Comme nous le savons, le framework possède différentes interfaces qui sont implémentées par de nombreuses classes à l'intérieur. Jetons maintenant un coup d'œil à quelques classes couramment utilisées.

Liste liée

Il s'agit de la structure de données la plus couramment utilisée qui implémente une liste doublement chaînée pour stocker les éléments qu'elle contient. Il peut stocker des éléments en double. Il implémente l'interface Dequeue étendue par l'interface Queue et l'interface List. Il n'est pas synchronisé. Voyons maintenant comment résoudre notre problème évoqué ci-dessus (le concept FIFO) en utilisant LinkedList. Le problème est de servir les clients de manière à ce qu'ils arrivent, c'est-à-dire premier entré, premier sorti .

Exemple

import java.util.*;
 
public class LinkedListExample {
    public static void main(String[] args) {
        Queue<String> customerQueue = new LinkedList<String>();
        //Adding customers to the Queue as they arrived
        customerQueue.add("John");
        customerQueue.add("Angelina");
        customerQueue.add("Brooke");
        customerQueue.add("Maxwell");
 
        System.out.println("Customers in Queue:"+customerQueue);
        //element() => returns head of the queue
        //we will see our first customer and serve him
        System.out.println("Head of the queue i.e first customer: "+customerQueue.element());
        //remove () method =>removes first element(customer) from the queue i.e the customer is served so remove him to see next
        System.out.println("Element removed from the queue: "+customerQueue.remove());
        //poll () => removes and returns the head
        System.out.println("Poll():Returned Head of the queue: "+customerQueue.poll());
        //print the remaining customers in the Queue
        System.out.println("Final Queue:"+customerQueue);
    }
}

Sortir

Liste des tableaux

Il implémente simplement l'interface List. Il maintient l'ordre d'insertion et utilise un tableau dynamique pour stocker des éléments de différents types de données. Les éléments peuvent être dupliqués. Il est également non synchronisé et peut stocker des valeurs nulles. Voyons maintenant ses différentes méthodes... Celles-ci sont utiles lorsque nous ne savons pas combien d'enregistrements ou d'éléments nous devons insérer. Prenons l'exemple d'une bibliothèque dans laquelle nous ne savons pas combien de livres nous devons conserver. Ainsi, chaque fois que nous avons un livre, nous devons l'insérer dans ArrayList.

Exemple

public class ArrayListExample {
	public static void main(String args[]) {
		
		// Creating the ArrayList
		ArrayList<String> books = new ArrayList<String>();
		
		// Adding a book to the list
		books.add("Absalom, Absalom!");
		// Adding a book in array list
		books.add("A Time to Kill");
		// Adding a book to the list
		books.add("The House of Mirth");
		// Adding a book to the list
		books.add("East of Eden");
		// Traversing the list through Iterator
		Iterator<String> itr = books.iterator();
		while (itr.hasNext()) {
			System.out.println(itr.next());
		}
	}
}

Sortir

Jeu de hachage

Il implémente l'interface Set et ne contient jamais de valeurs en double. Il implémente la table de hachage pour stocker les valeurs. Il autorise également les valeurs nulles. Il ne maintient jamais l'ordre d'insertion mais fournit des performances en temps constant pour les méthodes add , remove , size et contain . C'est le meilleur pour les opérations de recherche et il n'est pas synchronisé.

Exemple

import java.util.*;  
class HashSetExample{  
    public static void main(String args[]){  
        //creating HashSet and adding elements to it  
        HashSet<Integer> hashSet=new HashSet();  
        hashSet.add(1);    
        hashSet.add(5);    
        hashSet.add(4);   
        hashSet.add(3);  
        hashSet.add(2);  
        //getting an iterator for the collection
        Iterator<Integer> i=hashSet.iterator(); 
        //iterating over the value 
        while(i.hasNext())  {  
            System.out.println(i.next());  
        }  
    }  
}

Sortir

Comme vous pouvez le voir, il ne maintient pas l'ordre d'insertion.

TableauDeque

Il implémente l'interface Deque afin de permettre les opérations des deux côtés. Il n'autorise pas les valeurs nulles. Il est plus rapide que Stack et LinkedList lorsqu'il est implémenté en tant que Stack et LinkedList. ArrayDeque n'a aucune restriction de taille car il grandit et rétrécit selon les exigences. Il n’est pas synchronisé, ce qui signifie qu’il n’est pas thread-safe. Pour que cela reste thread-safe, nous devons implémenter une logique externe.

Exemple

import java.util.*;  
public class ArrayDequeExample {  
   public static void main(String[] args) {  
       //creating Deque and adding elements  
       Deque<String> deque = new ArrayDeque<String>();  
       //adding an element
       deque.add("One"); 
       //adding an element at the start
       deque.addFirst("Two");     
       //adding an element at the end
       deque.addLast("Three");    
       //traversing elements of the collection  
       for (String str : deque) {  
            System.out.println(str);  
       }  
   }  
}

Sortir

Carte de hachage

Il s'agit de l'implémentation de l'interface Map appuyée par la table de hachage. Il stocke les paires clé-valeur. Il n'autorise pas les valeurs nulles. Il n'est pas synchronisé. Il ne garantit jamais l’ordre d’insertion. Il fournit des performances en temps constant pour des méthodes telles que get et put . Ses performances dépendent de deux facteurs : la capacité initiale et le facteur de charge . La capacité est le nombre de compartiments dans la table de hachage, donc la capacité initiale est le nombre de compartiments alloués au moment de la création. Le facteur de charge est la mesure de la quantité de remplissage d'une table de hachage avant que sa capacité ne soit augmentée. La méthode de rehachage est utilisée pour augmenter la capacité et double principalement le nombre de seaux.

Exemple

import java.util.*;  
public class HashMapExample{  
    public static void main(String args[]){  
        //creating a HashMap
        HashMap<Integer,String> map=new HashMap<Integer,String>();    
        //putting elements into the map
        map.put(1,"England");    
        map.put(2,"USA");    
        map.put(3,"China");
        
        //get element at index 2
        System.out.println("Value at index 2 is: "+map.get(2));
        System.out.println("iterating map"); 
        //iterating the map 
        for(Map.Entry m : map.entrySet()){    
            System.out.println(m.getKey()+" "+m.getValue());    
        }   
    }  
}

Sortir

Algorithmes

Le framework Collections nous fournit différents algorithmes pour différentes opérations à appliquer aux collections. Nous examinerons ici quelles opérations majeures sont couvertes par ces algorithmes. Il contient des algorithmes liés à :

1. Tri
2. Recherche
3. Mélange
4. Manipulation de données de routine
5. Composition
6. Trouver des valeurs extrêmes

Pour une meilleure compréhension, nous discuterons de l'algorithme de tri.

Tri

L'algorithme de tri réorganise une liste selon une relation d'ordre. Deux formes de relations sont proposées.

1. Ordre naturel
2. Commande comparative

Ordre naturel

Dans l'ordre naturel, une liste est triée en fonction de ses éléments.

Commande comparative

Dans cette forme de commande, un paramètre supplémentaire, qui est un comparateur, est transmis avec la liste. Un algorithme de tri par fusion légèrement optimisé est utilisé pour le tri, qui est rapide et stable car il garantit la durée d'exécution de n log(n) et ne réorganise pas les éléments égaux. Nous utiliserons le même exemple d'ArrayList pour démontrer le tri.

Exemple

import java.util.*;  
public class SortingExample{  
    public static void main(String args[]){  
        //Creating arraylist
        ArrayList<String> books=new ArrayList<String>(); 
        //Adding a book to the arraylist
        books.add("A Time to Kill");
        //Adding a book to the arraylist
        books.add("Absalom, Absalom!");
        //Adding a book to the arraylist
        books.add("The House of Mirth");  
        //Adding a book to the arraylist
        books.add("East of Eden");
        //Traversing list through Iterator before sorting
        Iterator itrBeforeSort=books.iterator();  
        while(itrBeforeSort.hasNext()){  
            System.out.println(itrBeforeSort.next());  
        }
        //sorting the books
        Collections.sort(books);
        System.out.println("After sorting the books");
        //Traversing list through Iterator after sorting  
        Iterator itr=books.iterator();  
        while(itr.hasNext()){  
            System.out.println(itr.next());  
        }  
    }  
}

Sortir

Conclusion

Nous espérons que vous comprenez maintenant ce qu'est le framework de collections Java, quelles sont ses interfaces et ses classes et comment implémenter ses différentes classes. Vous pouvez toujours utiliser ce framework pour réduire vos efforts en Java. N'hésitez pas à vous entraîner et revenez ici chaque fois que vous avez besoin d'aide supplémentaire. Bon apprentissage!