Cadre de collecte Java a été introduit dans JDK 1.2 qui contient toutes les classes et interfaces de collection. Collection Java est un framework qui fournit un mécanisme pour stocker et manipuler la collection d'objets. Il permet aux développeurs d'accéder à des structures de données et à des algorithmes préemballés pour manipuler les données.
Dans cet article, nous avons couvert le top 50 Questions d'entretien chez Java Collections et réponses qui couvrent tout, des concepts de collection Java de base aux avancés tels que la collection de navigation, WeakHashMap, les flux Lambdas, etc. Que vous soyez un plus frais ou un développeur Java expérimenté , ces questions d'entretien sur les collections Java vous donnent toute la confiance dont vous avez besoin pour réussir votre prochain entretien Java.

Questions d'entretien chez Java Collections
Nous avons divisé les 50 questions en deux parties : Expérimentés et Freshers. Commençons par les questions destinées aux Freshers.
Table des matières
- Questions d'entretien sur la collection Java pour les débutants
- Questions d'entretien sur la collection Java pour les expérimentés
Questions d'entretien sur la collection Java pour les débutants
1. Qu'est-ce que la collection en Java ?
Le terme collection fait référence à un groupe d’objets représentés comme une seule unité. Les classes de la hiérarchie des classes de collection Java sont divisées en deux racine interfaces : Collection (java.util.Collection) et carte (java.util.Map) . Termes que vous rencontrerez en découvrant la collection en Java :
- Cadre de collecte : Le Collection Framework de Java définit des classes et des interfaces pour représenter des groupes d'objets comme une seule entité. Les développeurs C++ peuvent comparer le framework Collection avec STL (Bibliothèque de modèles standard) et Container Framework avec Collection Framework s’ils proviennent d’un arrière-plan C++.
- Interface de collecte : L’interface d’une classe spécifie ce qu’elle doit faire, pas comment. En d’autres termes, c’est le modèle de la classe. Cette interface fournit les méthodes les plus courantes pour tous les objets de collection qui font partie de Collection Framework. Alternativement, il représente l’objet individuel dans son ensemble.
- Classe de collecte : Membre de Collection Framework, il fait partie du package java.util. L'objet collection est fourni avec de nombreuses méthodes utilitaires dans cette classe.
2. Qu'est-ce qu'un framework en Java ?
Les cadres sont des ensembles de Des classes et interfaces qui fournissent une architecture prête à l’emploi. Il n'est pas nécessaire de définir un framework pour implémenter de nouvelles fonctionnalités ou classes. En conséquence, une conception orientée objet optimale inclut un cadre contenant un ensemble de classes qui effectuent toutes des tâches similaires. Le framework peut être utilisé de différentes manières, par exemple en appelant ses méthodes, en l'étendant et en fournissant des rappels, des écouteurs et d'autres implémentations. Certains des frameworks Java les plus populaires sont :
- Printemps
- Hiberner
- Jambes de force
- Boîte à outils Web Google (GWT)
- Visages du serveur Java (JSF)
3. Quelle est la différence entre Array et Collection en Java ?
Les tableaux sont une collection de variables de type similaire portant un nom commun en Java. Il existe quelques différences entre les tableaux en Java et en C/C++. D'autre part, les collections sont des groupes d'objets individuels qui forment une seule entité appelée collection d'objets.
| Tableaux | Collection |
|---|---|
| Les tableaux ont une taille fixe, c'est-à-dire qu'une fois que nous créons un tableau, nous ne pouvons pas l'augmenter ou le diminuer en fonction de nos besoins. | La collection est de nature cultivable et est basée sur nos exigences. Nous pouvons augmenter ou diminuer la taille. |
| En ce qui concerne la mémoire, l’utilisation des tableaux n’est pas recommandée. | En ce qui concerne la mémoire, l'utilisation des collections est recommandée. |
| En ce qui concerne les performances, l'utilisation des tableaux est recommandée. | En ce qui concerne les performances, l'utilisation des collections n'est pas recommandée. |
| Les tableaux ne peuvent contenir que des éléments de types de données homogènes. | La collection peut contenir des éléments à la fois homogènes et hétérogènes. |
Pour plus d’informations, reportez-vous à l’article – Différence entre les tableaux et les collections en Java
4. Quelles sont les différentes interfaces utilisées dans Java Collections Framework ?
La collection est connue comme la racine de la hiérarchie des collections. Les collections représentent des groupes d'objets appelés éléments. La plateforme Java ne fournit aucune implémentation directe de cette interface mais l'interface Collection est implémentée par les classes List et Set.
- Interface de collecte
- Interface de liste
- Définir l'interface
- Interface de file d'attente
- Interface de retrait de la file d'attente
- Interface cartographique
5. Expliquez la hiérarchie du framework Collection en Java.
Toutes les classes et interfaces requises par le framework de collection sont contenues dans le package utilitaire (java. util). Les frameworks de collections ont une interface appelée interface itérable, qui permet à l'itérateur d'itérer sur toutes les collections. En plus de cette interface, l'interface de collection principale fait office de racine pour le framework de collection. Toutes les collections étendent cette interface de collection étendant ainsi les propriétés de l'itérateur et les méthodes de cette interface. La figure suivante illustre la hiérarchie du cadre de collection.
Hiérarchie des collections Java
6. Quels sont les avantages du Framework de collecte ?
Avantages du cadre de collecte : Étant donné que l’absence d’un cadre de collecte a donné lieu à l’ensemble d’inconvénients ci-dessus, voici les avantages du cadre de collecte.
- API cohérente : L'API dispose d'un ensemble d'interfaces de base telles que Collection , Ensemble , Liste , ou Carte , toutes les classes (ArrayList, LinkedList, Vector, etc.) qui implémentent ces interfaces ont quelques ensemble commun de méthodes.
- Réduit les efforts de programmation : Un programmeur n’a pas à se soucier de la conception de la Collection mais peut plutôt se concentrer sur sa meilleure utilisation dans son programme. Par conséquent, le concept de base de la programmation orientée objet (c’est-à-dire) l’abstraction a été mis en œuvre avec succès.
- Augmente la vitesse et la qualité du programme : Augmente les performances en fournissant des implémentations hautes performances de structures de données et d'algorithmes utiles car dans ce cas, le programmeur n'a pas besoin de penser à la meilleure implémentation d'une structure de données spécifique. Il peut simplement utiliser la meilleure implémentation pour augmenter considérablement les performances de son algorithme/programme.
7. Qu'est-ce qu'ArrayList en Java ?
ArrayList fait partie du framework de collection Java et c'est une classe du package java.util. Il nous fournit des tableaux dynamiques en Java. Les principaux avantages d'ArrayList sont que si nous déclarons un tableau, il est nécessaire de mentionner la taille, mais dans ArrayList, il n'est pas nécessaire de mentionner la taille d'ArrayList si vous souhaitez mentionner la taille, vous pouvez le faire.

Image de la liste des tableaux
Pour plus d’informations, reportez-vous à l’article – Liste de tableaux en Java
8. Quelle est la différence entre Collection et Collections ?
| Collection | Collections |
|---|---|
| C'est une interface. | C'est une classe utilitaire. |
| Il est utilisé pour représenter un groupe d’objets individuels comme une seule unité. | Il définit plusieurs méthodes utilitaires utilisées pour opérer sur la collecte. |
| La Collection est une interface qui contient une méthode statique depuis java8. L'interface peut également contenir des méthodes abstraites et par défaut. | Il ne contient que des méthodes statiques. |
Pour plus d’informations, reportez-vous à l’article – Collection vs Collections en Java avec exemple
9. Différence entre ArrayList et LinkedList dans le framework de collection Java ?

ArrayList et LinkedList
| Liste des tableaux | Liste liée |
|---|---|
| Cette classe utilise un tableau dynamique pour y stocker les éléments. Avec l'introduction des génériques, cette classe prend en charge le stockage de tous types d'objets. | Cette classe utilise une liste doublement chaînée pour y stocker les éléments. Semblable à ArrayList, cette classe prend également en charge le stockage de tous les types d’objets. |
| La manipulation d'ArrayList prend plus de temps en raison de l'implémentation interne. Chaque fois que nous supprimons un élément, en interne, le tableau est parcouru et les bits de mémoire sont décalés. | La manipulation de LinkedList prend moins de temps que celle d'ArrayList car, dans une liste doublement liée, il n'y a aucun concept de décalage des bits de mémoire. La liste est parcourue et le lien de référence est modifié. |
| Cette classe implémente une interface List. Il s’agit donc d’une liste. | Cette classe implémente à la fois l'interface List et l'interface Deque. Par conséquent, il peut agir comme une liste et un deque. |
| Cette classe fonctionne mieux lorsque l'application demande de stocker les données et d'y accéder. | Cette classe fonctionne mieux lorsque l'application demande une manipulation des données stockées. |
Pour plus d’informations, reportez-vous à l’article – ArrayList vs LinkedList en Java
10. Qu'est-ce qu'un itérateur ?
Le framework Collection de Java utilise des itérateurs pour récupérer les éléments un par un. Cet itérateur est universel puisqu’il peut être utilisé avec tout type d’objet Collection. En utilisant Iterator, nous pouvons effectuer à la fois des opérations de lecture et de suppression. Il s'agit d'une version améliorée d'Enumeration avec l'ajout de la suppression d'éléments.
Lors de l'énumération des éléments dans toutes les interfaces implémentées du framework Collection, telles que Ensemble , Liste , File d'attente , De quoi , et toutes les classes implémentées de Map, un Iterator doit être utilisé. Le seul curseur disponible pour l’ensemble du framework de collection est l’itérateur. À l’aide de la méthode iterator() dans l’interface Collection, vous pouvez créer un objet itérateur.
Syntaxe:
Iterator itr = c. iterator ();>
Note: Ici, c est n’importe quel objet Collection. itr est de type Iterator interface et fait référence à c.
Pour plus d’informations, reportez-vous à l’article – Itérateurs en Java
11. Quelle est la différence entre un itérateur et une énumération ?
Une différence majeure entre l'itérateur et l'énumération est que les itérateurs ont une méthode Remove() alors que les énumérations n'en ont pas. Ainsi, en utilisant Iterator, nous pouvons manipuler des objets en les ajoutant et en les supprimant des collections. Puisque l'énumération ne peut que parcourir les objets et les récupérer, elle se comporte comme une interface en lecture seule.
Pour plus d’informations, reportez-vous à l’article – Différence entre itérateur et énumération
12. Quelle est la différence entre List et Set en Java
Une différence majeure entre une liste et un ensemble est qu'une liste peut contenir des éléments en double alors qu'un ensemble ne contient que des éléments uniques. La liste est Ordonnée et conserve l'ordre de l'objet auquel ils sont ajoutés. L'ensemble n'est pas commandé.
| Liste | Ensemble |
|---|---|
| La Liste est une séquence indexée. | L'ensemble est une séquence non indexée. |
| La liste autorise les éléments en double | L’ensemble n’autorise pas les éléments en double. |
| Les éléments par leur position sont accessibles. | L'accès à la position aux éléments n'est pas autorisé. |
| Plusieurs éléments nuls peuvent être stockés. | Les éléments nuls ne peuvent être stockés qu'une seule fois. |
| Les implémentations de liste sont ArrayList, LinkedList, Vector, Stack | Les implémentations d'ensemble sont HashSet, LinkedHashSet. |
Pour plus d’informations, reportez-vous à l’article – Différence entre liste et ensemble en Java
13. Quelles sont les meilleures pratiques pour Java Collections Framework ?
Voici quelques-unes des meilleures pratiques lors de l’utilisation des collections Java :
- Les programmes doivent être écrits sous forme d'interfaces et non d'implémentations, afin que nous puissions modifier l'implémentation ultérieurement.
- Dans la mesure du possible, utilisez Generics pour garantir la sécurité des types et éviter les ClassCastExceptions.
- Choisir le type de collecte approprié en fonction du besoin. Par exemple, si la taille est fixe, nous pourrions vouloir utiliser un Array sur un ArrayList. Lors de l'itération sur la carte, nous devons utiliser LinkedHashMap. Set est le meilleur moyen d’éviter les doublons.
- Utilisez les classes immuables fournies par JDK comme clés dans Map pour éviter l'implémentation de hashCode() et equals().
- Afin d'augmenter la lisibilité du code, nous devrions utiliser isEmpty() au lieu de trouver la taille de la collection et de la comparer à zéro.
- Plutôt que d'écrire votre propre implémentation, utilisez la classe utilitaire Collections pour obtenir des collections en lecture seule, synchronisées ou vides. Il améliore la réutilisation du code tout en offrant une plus grande stabilité.
14. Qu'est-ce qu'une file d'attente prioritaire en Java ?
Les PriorityQueues sont utilisées pour traiter les objets en fonction de leur priorité. Les files d'attente suivent l'algorithme First-In-First-Out, mais parfois les éléments de la file d'attente doivent être traités en fonction de leur priorité, c'est là que PriorityQueue entre en jeu. Les files d'attente prioritaires sont basées sur des tas prioritaires.
Les éléments de la file d'attente prioritaire sont ordonnés selon l'ordre naturel, ou par un comparateur fourni au moment de la construction de la file d'attente, selon le constructeur utilisé.

Files d'attente prioritaires en Java
Déclaration:
public class PriorityQueue extends AbstractQueue implements Serializable where E is the type of elements held in this queue>
La classe implémente les interfaces Serialisable, Itérable, Collection et Queue.
15. Quelle est la différence entre List, set et map en Java ?
| Liste | Ensemble | Carte |
|---|---|---|
| L'interface de liste permet des éléments en double | L'ensemble n'autorise pas les éléments en double. | La carte n'autorise pas les éléments en double |
| La liste conserve l'ordre d'insertion. | L'ensemble ne conserve aucun ordre d'insertion. | La carte ne conserve également aucun ordre d’insertion. ROM |
| Nous pouvons ajouter n'importe quel nombre de valeurs nulles. | Mais dans l'ensemble, il n'y a presque qu'une seule valeur nulle. | La carte autorise au maximum une seule clé nulle et un nombre quelconque de valeurs nulles. |
| Les classes d'implémentation de liste sont Array List et LinkedList. | Les classes d'implémentation d'ensemble sont HashSet, LinkedHashSet et TreeSet. | Les classes d'implémentation de carte sont HashMap, HashTable, TreeMap, ConcurrentHashMap et LinkedHashMap. |
Pour plus d’informations, reportez-vous à l’article – Différence entre liste, ensemble et carte en Java
16. Quelle est la différence entre la file d'attente et la pile ?
| Empiler | File d'attente |
|---|---|
| Stacks fonctionne sur le principe LIFO, ce qui signifie que l'élément inséré en dernier sera le premier élément qui sera retiré. | Les files d'attente fonctionnent selon le principe FIFO, ce qui signifie que l'élément inséré en premier sera le premier élément qui sera retiré. |
| Dans les piles, l'insertion et la suppression s'effectuent uniquement par le haut. | Dans les files d'attente, l'insertion s'effectue à la fin de la liste et la suppression s'effectue au début de la liste. |
| L’opération d’insertion est appelée opération de poussée. | L’opération d’insertion est appelée opération de mise en file d’attente. |
| L’opération de suppression est appelée opération pop. | L’opération de suppression est appelée opération de retrait de la file d’attente. |
| Le haut d'une pile pointe toujours vers le dernier élément de la liste, qui est le seul pointeur utilisé pour accéder à la liste. | Deux pointeurs sont conservés pour accéder aux files d'attente. Le pointeur avant pointe vers le premier élément inséré et le pointeur arrière pointe vers le dernier élément inséré. |
17. Qu'est-ce que BlockingQueue en Java ?
L'interface BlockingQueue en Java est ajoutée dans Java 1.5 avec diverses autres classes utilitaires concurrentes telles que ConcurrentHashMap, Counting Semaphore, CopyOnWriteArrrayList, etc. L'interface BlockingQueue prend en charge le contrôle de flux (en plus de la file d'attente) en introduisant le blocage si BlockingQueue est plein ou vide.
Un thread essayant de mettre un élément dans une file d'attente pleine est bloqué jusqu'à ce qu'un autre thread libère de l'espace dans la file d'attente, soit en retirant un ou plusieurs éléments de la file d'attente, soit en effaçant complètement la file d'attente. De même, il bloque un thread essayant de supprimer d'une file d'attente vide jusqu'à ce que d'autres threads insèrent un élément. BlockingQueue n'accepte pas de valeur nulle. Si nous essayons de mettre l'élément nul en file d'attente, il lève NullPointerException.
Utilisation de BlockingQueue

Blocage de la file d'attente en Java
La hiérarchie de BlockingQueue

Hiérarchie de la file d'attente de blocage en Java
Déclaration:
public interface BlockingQueue extends Queue>
Ici, ET est le type d'éléments stockés dans la collection.
Pour plus d’informations, reportez-vous à l’article – Interface BlockingQueue en Java
18. Qu'est-ce que hashCode() ?

Image pour démontrer le code de hachage Java
La méthode hashCode() renvoie la valeur du hashcode sous forme d'entier. Il est défini dans la classe Java Object qui calcule les valeurs de hachage des objets d'entrée donnés. La valeur du hashcode est principalement utilisée dans les collections basées sur le hachage comme HashMap, HashSet, HashTable….etc. Cette méthode doit être remplacée dans chaque classe qui remplace la méthode equals().
Syntaxe :
public int hashCode() // This method returns the hash code value // for the object on which this method is invoked.>
Pour plus d’informations, reportez-vous à l’article – Méthodes equals() et hashCode() en Java
19. Distinguer ArrayList et Vector dans Java Collection Framework.
Lors des entretiens de collecte, cette question est fréquemment posée ; cependant, Vector est synchronisé alors que ArrayList ne l'est pas. ArrayList est plus rapide que Vector. La taille du tableau d'ArrayList est augmentée de 50 % en cas de besoin, tandis que la capacité de Vector est doublée chaque fois que cela est nécessaire.

Liste de tableaux vs vecteur en Java
| Liste des tableaux | Vecteur |
|---|---|
| ArrayList n'est pas synchronisé | Le vecteur est synchronisé. |
| La taille d'ArrayList est incrémentée jusqu'à 50 % de la taille actuelle du tableau si le nombre d'éléments dépasse sa capacité. | La taille d'ArrayList est incrémentée jusqu'à 100 % de la taille actuelle du tableau si le nombre d'éléments dépasse sa capacité. |
| ArrayList est rapide car il n'est pas synchronisé. | Le vecteur est plus lent car il est synchronisé. |
| L'interface itérateur est utilisée pour parcourir les éléments | Une interface itératrice ou une énumération peut être utilisée pour parcourir le vecteur. |
Pour plus d’informations, reportez-vous à l’article – Vecteur vs ArrayList en Java
20. Faites la différence entre Iterator et ListIterator.
| Itérateur | ListItérateur |
|---|---|
| Peut traverser les éléments présents dans Collection uniquement dans le sens avant. | Peut parcourir les éléments présents dans la collection à la fois vers l'avant et vers l'arrière. |
| Aide à parcourir la carte, la liste et l'ensemble. | Ne peut parcourir que List et pas les deux autres. |
| Les index ne peuvent pas être obtenus à l’aide d’Iterator. | Il dispose de méthodes telles que nextIndex() et previousIndex() pour obtenir les index des éléments à tout moment lors du parcours de la liste. |
| Impossible de modifier ou de remplacer les éléments présents dans la Collection | On peut modifier ou remplacer des éléments à l'aide de set(E e) |
Pour plus d’informations, reportez-vous à l’article – Différence entre un itérateur et ListIterator
21. Quelle est la différence entre un itérateur et une énumération ?
Itérateur : C'est un itérateur universel car nous pouvons l'appliquer à n'importe quel objet Collection. En utilisant un itérateur, nous pouvons effectuer à la fois des opérations de lecture et de suppression.
Syntaxe:
// Here 'c' is any Collection object. itr is of // type Iterator interface and refers to 'c' Iterator itr = c.iterator();>
Énumération: L'énumération (ou enum) est un type de données défini par l'utilisateur. Il est principalement utilisé pour attribuer des noms aux constantes intégrales, les noms rendent un programme facile à lire et à maintenir.
Syntaxe:
// A simple enum example where enum is declared // outside any class (Note enum keyword instead of // class keyword) enum Color { RED, GREEN, BLUE; }> | Itérateur | Énumération |
|---|---|
| L'itérateur est un curseur universel car il s'applique à toutes les classes de collection. | L'énumération n'est pas un curseur universel car elle s'applique uniquement aux classes héritées. |
| L'itérateur a la méthode Remove(). | L'énumération n'a pas la méthode Remove(). |
| L'itérateur peut effectuer des modifications (par exemple en utilisant la méthode remove() qui supprime l'élément de la collection pendant le parcours). | L'interface d'énumération agit comme une interface en lecture seule, on ne peut apporter aucune modification à la Collection en parcourant les éléments de la Collection. |
| Iterator n’est pas une interface héritée. Iterator peut être utilisé pour parcourir HashMap, LinkedList, ArrayList, HashSet, TreeMap et TreeSet. | L'énumération est une interface héritée utilisée pour parcourir Vector et Hashtable. |
Pour plus d’informations, reportez-vous à l’article – Différence entre itérateur et énumération
22. Quelles sont les fonctionnalités de Java Hashmap ?
HashMap est similaire à HashTable, mais il n'est pas synchronisé. Cela nous permet également de stocker les clés nulles, mais il ne devrait y avoir qu'un seul objet clé nulle et il peut y avoir n'importe quel nombre de valeurs nulles. Cette classe ne donne aucune garantie quant à l'ordre de la carte. Pour utiliser cette classe et ses méthodes, vous devez importer java.util. Carte de hachage package ou sa superclasse.

HashMap en Java
Syntaxe:
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable>
Paramètres: Il faut deux paramètres à savoir les suivants :
- Le type de clés maintenues par cette carte (K)
- Le type de valeurs mappées (V)
Pour plus d’informations, reportez-vous à l’article – HashMap en Java avec exemples
23. Que sont les interfaces de collecte ?
Le Collection L'interface est membre de Java Collections Framework. C'est une partie de java.util emballer. C'est l'une des interfaces racine de la hiérarchie de collections. L’interface Collection n’est directement implémentée par aucune classe. Cependant, il est implémenté indirectement via ses sous-types ou sous-interfaces comme List, Queue et Set.
Par exemple, la classe HashSet implémente l'interface Set qui est une sous-interface de l'interface Collection. Si une implémentation de collection n’implémente pas une opération particulière, elle doit définir la méthode correspondante pour lancer UnsupportedOperationException.
La hiérarchie de collecte :

Interface de collecte en Java
24. Expliquez l'interface de liste.

Interface de classe en Java
En Java, l'interface List permet à l'utilisateur de stocker une collection ordonnée d'objets. La liste est l'interface enfant de Collection. Dans Collection, une liste est une collection ordonnée d’objets pouvant avoir des valeurs en double. Puisque List préserve l'ordre d'insertion, il permet l'accès et l'insertion positionnels, ce qui autorise également les valeurs en double.
Syntaxe:
public interface List extends Collection ;>
Cette interface de liste est implémentée par diverses classes comme ArrayList, Vector, Stack, etc. Puisque toutes les sous-classes implémentent la liste, nous pouvons instancier un objet liste avec n'importe laquelle de ces classes.
Exemple:
Liste al = new ArrayList ();
Liste ll = nouvelle LinkedList ();
Liste v = nouveau vecteur ();Où T est le type de l'objet

Liste de tableaux en Java
Les classes qui implémentent l'interface List sont les suivantes :
- Liste des tableaux
- Liste liée
- Vecteur
- Empiler
25. Écrivez un programme pour convertir un tableau donné en une collection avec la méthode asList().
Pour convertir des données basées sur un tableau en données basées sur une collection, nous pouvons utiliser java.util.Arrays classe. Cette classe fournit une méthode statique asList(T… a) qui convertit le tableau en une collection.
Java
// Convert an Array into Collection in Java> // import java util library> import> java.util.*;> > // class for writing logic of the problem> public> class> ArrayToCollection {> >public> static> void> main(String args[])> >{> >// array input> >String students[] = {>'Kamlesh'>,>'Abhay'>,> >'Abhishek'>,>'Shivansh'> };> > >// printing input elements for comparison> >System.out.println(>'Array input: '> >+ Arrays.toString(students));> > >// converting array into Collection> >// with asList() function> >List studentList = Arrays.asList(students);> > >// print converted elements> >System.out.println(>'Converted elements: '> >+ studentList);> >}> }> |
types de données Java
>
>Sortir
Array input: [Kamlesh, Abhay, Abhishek, Shivansh] Converted elements: [Kamlesh, Abhay, Abhishek, Shivansh]>
26. Différencier HashSet et HashMap
| Jeu de hachage | Carte de hachage |
|---|---|
| HashSet implémente l'interface Set | HashMap implémente l'interface Map |
| Aucun doublon n'est autorisé | Oui, les valeurs en double sont autorisées mais aucune clé en double n'est autorisée |
| Les valeurs factices sont autorisées dans HashSet. | Aucune valeur factice n'est autorisée dans HashMap. |
| Un seul objet est requis lors d'une opération d'ajout | 2 objets sont requis lors d'une opération d'ajout |
| La vitesse est comparativement plus lente que HashMap | La vitesse est comparativement plus rapide que celle de HashSet en raison de la technique de hachage utilisée ici. |
| Avoir une seule valeur nulle | Clé nulle unique et n'importe quel nombre de valeurs nulles |
| La méthode Add() est utilisée pour l'insertion | La méthode put() est utilisée pour l'insertion. |
Pour plus d’informations, reportez-vous à l’article – Différence entre HashMap et HashSet
27. Faites la différence entre HashSet et HashTable.
| Jeu de hachage | Table de hachage |
|---|---|
| HashSet autorise les éléments NULL | HashTable n'autorise pas les éléments NULL. |
| Il n'est pas garanti que les objets que vous insérez dans HashSet soient insérés dans le même ordre. Les objets sont insérés en fonction de leur code de hachage. LinkedHashSet peut être utilisé pour maintenir l’ordre. | HashTable ne maintient pas l'ordre d'insertion. |
| HashSet n'est pas synchronisé mais il peut être synchronisé en externe. | HashTable est synchronisée. |
| La méthode add() est utilisée pour insérer dans HashSet | La méthode put() est utilisée pour insérer dans HashTable |
28. Quelle est la taille par défaut du facteur de charge dans la collection basée sur le hachage ?
À mesure que le facteur de charge augmente, la capacité augmente de sorte que la complexité opérationnelle du HashMap reste O(1) si le rapport entre l'élément actuel et la capacité initiale dépasse le seuil. La signification de la complexité opérationnelle de O(1) signifie que les opérations de récupération et d’insertion prennent un temps constant. La taille du facteur de charge par défaut est 0,75 . La capacité par défaut est calculée en multipliant la capacité initiale par le facteur de charge.
Pour plus d’informations, reportez-vous à l’article – Facteur de charge dans HashMap en Java avec exemples
Questions d'entretien sur la collection Java pour les expérimentés
29. Quelle est la différence entre Comparable et Comparator en Java ?
Java fournit deux interfaces pour trier les objets à l'aide des données membres de la classe :
- Comparable
- Comparateur
| Comparable | Comparateur |
|---|---|
| L’interface Comparable fournit une séquence de tri unique. | L'interface Comparator fournit plusieurs séquences de tri. |
| La classe réelle est modifiée par une interface comparable | La classe réelle n'est pas modifiée par l'interface Comparator. |
| La méthode compareTo() est utilisée pour trier les éléments. | La méthode compare() est utilisée pour trier les éléments. |
| Comparable est présent dans le package java.lang | Le comparateur est présent dans le package java.util |
Pour plus d’informations, reportez-vous à l’article – Comparable vs Comparateur en Java
30. Quelle est la différence entre fail-fast et failsafe ?
Les itérateurs en Java sont utilisés pour parcourir les objets Collection. Les itérateurs Fail-Fast lancent immédiatement ConcurrentModificationException s'il y a un modification structurelle de la collection. La modification structurelle signifie l'ajout ou la suppression d'un élément d'une collection pendant qu'un thread parcourt cette collection. Les classes Iterator sur ArrayList et HashMap sont quelques exemples d'Iterator à échec rapide.
| Échec rapide | Sécurité intégrée |
|---|---|
| ConcurrentModificationException est levée lors de la modification de l'objet pendant le processus d'itération. | Aucune exception n'est levée |
| Fail-Fast a besoin de moins de mémoire pendant le processus. | L’itérateur Fail-Safe nécessite plus de mémoire pendant le processus. |
| Un objet clone n'est pas créé pendant le processus d'itération. | Un objet clone ou une copie est créé pendant le processus d'itération. |
| Fail-Fast ne permet pas de modification pendant le processus d'itération. | Fail-Safe permet la modification pendant le processus d'itération. |
| Fail-Fast est rapide, | Fail-Safe est légèrement plus lent que Fail Fast. |
| Exemples: ArrayList, vecteur, HashMap, HashSet, etc. | Exemples: ConcurrentHashMap, CopyOnWriteArrayList, etc. |
Pour plus d’informations, reportez-vous à l’article – Itérateurs Fail Fast et Fail Safe en Java
31. Écrivez un programme pour parcourir la liste en utilisant l'expression lambda.
L'itération peut être effectuée à l'aide d'un expression lambda.
Syntaxe:
list_name.forEach(variable->{//bloc de code})> Java
// Java Program to iterate over a List> // using forEach()> > // Importing all classes of> // java.util method> import> java.util.*;> > // Class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an ArrayList> >List l =>new> ArrayList();> > >// Adding elements to the List> >// Custom inputs> >l.add(>'Geeks'>);> >l.add(>'for'>);> >l.add(>'Geeks'>);> > >// Lambda expression printing all elements in a List> >l.forEach((temp) ->{ System.out.println(temp); });> >}> }> |
>
>Sortir
Geeks for Geeks>
Pour plus d’informations, reportez-vous à l’article – Parcourir la liste en Java
32. Qu'est-ce qu'IdentityHashMap ?
IdentityHashMap implémente l'interface Map à l'aide de Hashtable, en comparant les clés (et les valeurs) en utilisant l'égalité de référence au lieu de l'égalité d'objet. Cette classe implémente l'interface Map, mais elle rompt intentionnellement le contrat général de Map, qui exige que les objets soient comparés à l'aide de la méthode equals(). Cette classe est utilisée lorsque l'utilisateur autorise la comparaison d'objets à l'aide de références. Il appartient au package java.util.
Pour plus d’informations, reportez-vous à l’article – Classe IdentityHashMap en Java
33. Écrivez un programme en Java pour afficher le contenu d'une HashTable à l'aide d'une énumération.
La classe hashtable implémente une table de hachage, qui mappe les clés aux valeurs. Tout objet non nul peut être utilisé comme clé ou comme valeur. Pour réussir à stocker et récupérer des objets d'une table de hachage, les objets utilisés comme clés doivent implémenter la méthode hashCode et la méthode equals. Vous trouverez ci-dessous le programme permettant d'afficher le contenu d'une HashTable à l'aide d'une énumération :
Java
// Java Program to Demonstrate Getting Values> // as an Enumeration of Hashtable class> > import> java.io.*;> import> java.util.Enumeration;> import> java.util.Hashtable;> > // Main class> // EnumerationOnKeys> public> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Creating an empty hashtable> >Hashtable hash> >=>new> Hashtable();> > >// Inserting key-value pairs into hash table> >// using put() method> >hash.put(>1>,>'Geeks'>);> >hash.put(>2>,>'for'>);> >hash.put(>3>,>'Geeks'>);> > >// Now creating an Enumeration object> >// to read elements> >Enumeration e = hash.elements();> > >// Condition holds true till there is> >// single key remaining> > >// Printing elements of hashtable> >// using enumeration> >while> (e.hasMoreElements()) {> > >// Printing the current element> >System.out.println(e.nextElement());> >}> >}> }> |
>
>Sortir
Geeks for Geeks>
34. Écrivez un programme en Java pour obtenir la vue de collection des valeurs présentes dans un HashMap.
La classe HashMap de Java possède la méthode java.util.HashMap.values() pour créer des collections à partir des valeurs HashMap. Il renvoie essentiellement une vue Collection des valeurs HashMap.
Java
// Java code to illustrate the values() method> import> java.util.*;> > public> class> Hash_Map_Demo {> >public> static> void> main(String[] args)> >{> > >// Creating an empty HashMap> >HashMap hash_map> >=>new> HashMap();> > >// Mapping string values to int keys> >hash_map.put(>0>,>'Welcome'>);> >hash_map.put(>1>,>'to'>);> >hash_map.put(>2>,>'Geeks'>);> >hash_map.put(>3>,>'4'>);> >hash_map.put(>4>,>'Geeks'>);> > >// Displaying the HashMap> >System.out.println(>'Initial Mappings are: '> >+ hash_map);> > >// Using values() to get the set view of values> >System.out.println(>'The collection is: '> >+ hash_map.values());> >}> }> |
>
>Sortir
Initial Mappings are: {0=Welcome, 1=to, 2=Geeks, 3=4, 4=Geeks} The collection is: [Welcome, to, Geeks, 4, Geeks]> Pour plus d’informations, reportez-vous à l’article – Méthode HashMap valeurs () en Java
35. Écrivez un programme pour joindre deux ArrayList en une seule ArrayList.
Étant donné deux ArrayLists en Java, notre tâche est de joindre ces ArrayLists.
Java
// Java program to demonstrate> // How to join ArrayList> > import> java.util.*;> > public> class> GFG {> >public> static> void> main(String args[])> >{> > >ArrayList list_1 =>new> ArrayList();> > >list_1.add(>'Geeks'>);> >list_1.add(>'For'>);> >list_1.add(>'ForGeeks'>);> > >// Print the ArrayList 1> >System.out.println(>'ArrayList 1: '> + list_1);> > >ArrayList list_2 =>new> ArrayList();> > >list_2.add(>'GeeksForGeeks'>);> >list_2.add(>'A computer portal'>);> > >// Displaying the ArrayList 2> >System.out.println(>'ArrayList 2: '> + list_2);> > >// using Collection.addAll() method to join two> >// arraylist> >list_1.addAll(list_2);> > >// Print the joined ArrayList> >System.out.println(>'Joined ArrayLists: '> + list_1);> >}> }> |
>
comment trier une liste de tableaux en Java
>Sortir
ArrayList 1: [Geeks, For, ForGeeks] ArrayList 2: [GeeksForGeeks, A computer portal] Joined ArrayLists: [Geeks, For, ForGeeks, GeeksForGeeks, A computer portal]>
Pour plus d’informations, reportez-vous à l’article – Rejoignez deux ArrayLists en Java
36. Comment synchroniser une ArrayList en Java ?
En utilisant la méthode Collections.synchronizedList(), nous pouvons synchroniser nos collections en Java. SynchronizedList() renvoie une liste synchronisée (thread-safe) appuyée par une sélection.
Java
// Java program to show synchronization of ArrayList> import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Non Synchronized ArrayList> >List list =>new> ArrayList();> > >list.add(>'Eat'>);> >list.add(>'Coffee'>);> >list.add(>'Code'>);> >list.add(>'Sleep'>);> >list.add(>'Repeat'>);> > >// Synchronizing ArrayList in Java> >list = Collections.synchronizedList(list);> > >// we must use synchronize block to avoid> >// non-deterministic behavior> >synchronized> (list)> >{> >Iterator it = list.iterator();> >while> (it.hasNext()) {> >System.out.println(it.next());> >}> >}> >}> }> |
>
>Sortir
Eat Coffee Code Sleep Repeat>
37. Qu'est-ce qu'une classe de propriétés en Java ?
La classe Properties est une sous-classe de Hashtable. La classe Properties stocke une liste de valeurs dont la clé est une chaîne et dont la valeur est également une chaîne. Les propriétés peuvent définir d'autres listes de classes de propriétés, mais la valeur par défaut est propriétés.
Caractéristiques de la classe Propriétés :
- La propriété est une sous-classe de Hashtable.
- Le fichier Propriétés est utilisé pour stocker et récupérer le type de données chaîne pour une liste de valeurs où la clé est une chaîne et la valeur est également une chaîne.
- Si la liste des propriétés d'origine ne contient pas une certaine propriété clé, la liste des propriétés par défaut sera recherchée à la place.
- Les objets peuvent être partagés par plusieurs threads sans synchronisation externe.
- La classe Properties peut être utilisée pour récupérer les propriétés du système.
Pour plus d’informations, reportez-vous à l’article – Classe de propriétés en Java
38. Que se passera-t-il si vous utilisez HashMap dans une application Java multithread ?
Dans un environnement multithread, si plusieurs threads modifient structurellement la carte, par exemple en ajoutant, supprimant ou modifiant des mappages, la structure de données interne de HashMap peut être corrompue et il peut y avoir des liens manquants, des entrées incorrectes et la carte elle-même peut devenu complètement inutile. Ainsi, vous ne devez pas utiliser HashMap dans une application simultanée ; utilisez plutôt ConcurrentHashMap ou Hashtable qui est thread-safe. Le ConcurrentHashMap inclut toutes les méthodes de Hashtable ainsi qu’une simultanéité complète des récupérations et des mises à jour.
Comment ThreadSafeConcurrentHashMap est-il devenu thread-safe ?
- La classe java.util.Concurrent.ConcurrentHashMap assure la sécurité des threads en divisant la carte en segments, ce qui permet au verrou d'être pris une seule fois par segment, c'est-à-dire une fois pour chaque thread.
- L'opération de lecture dans ConcurrentHashMap ne nécessite pas de verrou.
Pour plus d’informations, reportez-vous à l’article – Comment ConcurrentHashMap assure-t-il la sécurité des threads en Java ?
39. Que se passera-t-il si deux clés différentes de HashMap renvoient le même hashcode() ?
Lorsque deux clés différentes de HashMap renvoient le même code de hachage, elles se retrouveront dans le même bucket ; par conséquent, des collisions se produiront. En cas de collision, c'est-à-dire que l'index de deux nœuds ou plus est le même, les nœuds sont joints par une liste de liens, c'est-à-dire que le deuxième nœud est référencé par le premier nœud et le troisième par le deuxième, et ainsi de suite.
Pour plus d’informations, reportez-vous à l’article – Fonctionnement interne de HashMap en Java
40. Qu'est-ce que WeakHashMap ?
WeakHashMap implémente l'interface Map. Contrairement à HashMap, WeakHashMap permet le garbage collection même si l'objet spécifié comme clé ne contient aucune référence bien qu'il soit associé à WeakHashMap. En d’autres termes, Garbage Collector est meilleur que WeakHashMap.
Pour plus d’informations, reportez-vous à l’article – Hashmap vs WeakHashMap en Java
41. Qu'est-ce qu'UnsupportedOperationException ?
Dans le contexte des API ou des implémentations de listes, UnsupportedOperationException est une exception courante. L'exception est levée lorsque l'opération demandée ne peut pas être effectuée. Cette classe est membre de Java Collections Framework.
Syntaxe:
public class UnsupportedOperationException extends RuntimeException>
Pour plus d’informations, reportez-vous à l’article – UnsupportedOperationException
42. Comment créer une collection en lecture seule en Java ?
La création d'une collection en lecture seule implique de restreindre l'objet à la récupération uniquement des données et non à l'ajout ou à la suppression de données. Java a différentes méthodes pour différents types de collections comme unmodifiableCollection(), unmodifiableMap(), ununmodifiableSet(), etc. java.util.La classe collections définit toutes les méthodes. La méthode unmodifiableCollection() crée une collection en lecture seule. Cela nécessite une référence à la classe Collection. Si nous avons un objet de Set Interface, nous pouvons utiliser ununmodifiableSet() pour faire en lecture seule.
Pour plus d’informations, reportez-vous à l’article – Comment créer une collection en lecture seule en Java ?
43. Différence entre PriorityQueue et TreeSet en Java ?
| File d'attente de priorité | Ensemble d'arbres |
|---|---|
| PriorityQueue est disponible dans JDK 1.5. | TreeSet est livré dans JDK 1.4. |
| La structure de données utilisée par PriorityQueue est Queue | La structure de données utilisée par TreeSet est Set. |
| Les éléments en double sont autorisés. | Les éléments en double ne sont pas autorisés. |
| À l'exception de l'élément racine, le reste des éléments ne suit aucun ordre particulier dans PriorityQueue. | Dans TreeSet, tous les éléments restent dans l'ordre trié. |
| En utilisant PriorityQueue, nous pouvons récupérer le plus grand ou le plus petit élément en un temps O(1). | TreeSet ne fournit pas de moyen de récupérer le plus grand ou le plus petit élément en temps O(1), mais comme ils sont dans l'ordre trié, il obtient le premier ou le dernier élément en temps O(1). |
Pour plus d’informations, reportez-vous à l’article – Différence entre PriorityQueue et TreeSet
44. Qu'est-ce que l'opérateur diamant en Java ?
Les opérateurs Diamond sont utilisés pour simplifier l'utilisation de génériques lors de la création d'objets tout en évitant les avertissements non vérifiés dans un programme. Lorsque l'opérateur Diamond a été introduit dans Java 7, nous pouvons créer l'objet sans mentionner le type générique sur le côté droit de l'expression, comme indiqué ci-dessous.
Syntaxe:
List list = new ArrayList();>
Pour plus d’informations, reportez-vous à l’article – Opérateur de diamant
45. Comment fonctionne TreeMap en Java ?
ArbreCarte stocke les paires clé-valeur, mais TreeMap trie les clés par ordre croissant plutôt que décroissant comme HashMap. Selon le constructeur utilisé, TreeMap sera trié soit en fonction de ses clés, soit par un comparateur. Dans TreeMap, les éléments sont triés selon un arbre Rouge-Noir. Un arbre rouge-noir est un arbre de recherche binaire auto-équilibré dans lequel chaque nœud possède un bit supplémentaire, et ce bit est souvent interprété comme la couleur (rouge ou noir). Ces couleurs sont utilisées pour garantir que l'arborescence reste équilibrée lors des insertions et des suppressions.

Structure d'un nœud en Java
Pour plus d’informations, reportez-vous à l’article – Fonctionnement interne de TreeMap en Java
46. Répertoriez les façons de parcourir Map en Java ?
La classe HashMap fournit l'interface Map de Java en stockant les données dans des paires (Clé, Valeur) et en y accédant par un index d'un autre type. Pour utiliser cette classe il faut importer java.util.HashMap package ou sa superclasse.
Il existe de nombreuses façons de parcourir HashMap, dont 5 sont répertoriées ci-dessous :
- Parcourez un HashMap EntrySet à l’aide d’itérateurs.
- Parcourez HashMap KeySet à l’aide d’Iterator.
- Itérer HashMap en utilisant la boucle for-each.
- Itérer sur un HashMap à l'aide d'expressions Lambda.
- Parcourez un HashMap à l’aide de l’API Stream.
Pour plus d’informations, reportez-vous à l’article – Comment itérer HashMap en Java
47. Qu'est-ce que CopyOnWriteArrayList en Java ?

CopyOnWriteArrayList en Java
JDK 1.5 a introduit une version améliorée d'ArrayList appelée CopyOnWriteArrayList, où toutes les modifications (ajouter, définir, supprimer, etc.) sont implémentées par une nouvelle copie. Il peut être trouvé dans java.util.concurrent. Il s'agit d'une structure de données créée pour être utilisée dans un environnement concurrent. Dans un environnement basé sur Thread, CopyOnWriteArrayList est destiné à une lecture fréquente et à une mise à jour peu fréquente. CopyOnWriteArrayList est une version thread-safe d'ArrayList.
Pour plus d’informations, reportez-vous à l’article – CopyOnWriteArrayList en Java
48. Qu'est-ce qu'EnumMap en Java ?
EnumMap est une implémentation de l'interface Map spécifique aux types d'énumération. La classe EnumMap est membre de Java Collections Framework et n'est pas synchronisée. Il étend AbstractMap et implémente l'interface Map en Java. EnumMap appartient au package java.util.
Syntaxe:
classe publique EnumMap
étend AbstractMap implémente Serialisable, Cloneable formule de maçon// K doit étendre Enum, ce qui impose l'exigence selon laquelle les clés doivent être du type enum spécifié.
Paramètres:
- Type d'objet clé
- Type d'objet valeur

EnumMap en Java
Pour plus d’informations, reportez-vous à l’article – Classe EnumMap en Java
49. Comment fonctionne Hashmap en interne ?
HashMap fonctionne sur le principe du Hashing. HashMap contient un tableau de Node et Node peut représenter une classe ayant les objets suivants :
- hachage entier
- Clé K
- Valeur V
- Nœud suivant
Le fonctionnement interne de HashMap :
- Hachage
- Godets
- Calcul d'index dans Hashmap
Pour plus d’informations, reportez-vous à l’article – Fonctionnement interne de HashMap en Java
cinquante. Pourquoi l'itérateur dans hashmap est considéré comme un échec rapide ?
Les itérateurs à échec rapide lèvent immédiatement des exceptions de modification simultanées si un thread extérieur tente de modifier la collection sur laquelle ils itèrent. La fonctionnalité d'échec rapide garantit que l'itérateur échoue immédiatement s'il détecte que toute modification de la collection entraînera un comportement anormal dans le futur.
Échouer rapidement La fonctionnalité garantit que si l'itérateur estime que la modification de la collection entraînerait un comportement anormal à tout moment dans le futur, il échoue immédiatement.
Exemple:
Java
// Java code to demonstrate remove> // case in Fail-fast iterators> > import> java.io.*;> import> java.util.ArrayList;> import> java.util.Iterator;> > public> class> GFG {> >public> static> void> main(String[] args)> >{> >ArrayList arr =>new> ArrayList();> >arr.add(>1>);> >arr.add(>2>);> >arr.add(>3>);> >arr.add(>4>);> >arr.add(>5>);> > >Iterator it = arr.iterator();> >while> (it.hasNext()) {> >if> (it.next() ==>2>) {> >// will not throw Exception> >it.remove();> >}> >}> > >System.out.println(arr);> > >it = arr.iterator();> >while> (it.hasNext()) {> >if> (it.next() ==>3>) {> >// will throw Exception on> >// next call of next() method> >arr.remove(>3>);> >}> >}> >}> }> |
>
>
Sortir:
[1, 3, 4, 5] Exception in thread 'main' java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901) at java.util.ArrayList$Itr.next(ArrayList.java:851) at FailFastExample.main(FailFastExample.java:28)>
Conclusion
Collections Java est important à comprendre pour les développeurs ou programmeurs Java, car Java est largement utilisé dans diverses industries. Il est important que les développeurs aient une solide compréhension des concepts fondamentaux des collections Java. Java est l'un des langages les plus utilisés dans les grandes entreprises telles que Uber , Airbnb , Google , Netflix , Instagram , Spotify, Amazone , etc. Pour entrer dans ces entreprises ou dans toute autre société informatique, vous devez maîtriser ces questions d'entretien les plus fréquemment posées par Java Collections afin de réussir leur évaluation en ligne et leur entretien technique basés sur Java.
Si vous souhaitez vous entraîner à des questions de codage, le Programmes de collecte JAVA peut être une ressource utile.
Questions d'entretien sur les collections Java - FAQ
1. Que sont les collections dans les questions d'entretien Java ?
Collection en Java est un framework utilisé pour stocker et manipuler des collections d'objets.
2. Quelles sont les 4 classes de collection en Java ?
Il existe de nombreuses collections en Java, mais parmi elles les collections les plus utilisées sont :
- Liste des tableaux
- Liste liée
- Jeu de hachage
- Empiler
3. HashMap peut-il avoir des clés en double ?
Non, HashMap ne peut pas avoir de clés en double. Comme HashMap est l'une des collections de Java, elle stocke la valeur sous forme de clé-valeur et chaque clé est associée à sa propre valeur. Ainsi, comme aucune clé ne peut avoir deux valeurs, nous ne pouvons pas avoir de clés en double dans HashMap.
4. Pourquoi le tableau n'est-il pas une collection ?
Le tableau n'est pas une collection, tout cela est dû à la différence de fonctionnalité entre les collections et les tableaux, dont quelques-unes sont mentionnées ci-dessous :
- La taille du tableau ne peut pas être modifiée une fois déclarée
- Les tableaux ne peuvent contenir que des éléments de types de données homogènes.
- Le tableau peut contenir à la fois des types de données primitifs et des objets, alors que dans les collections, il ne peut contenir que des objets wrapper.