set interface java
Ce didacticiel Java Set explique tout sur l'interface Set en Java. Il explique comment itérer dans un ensemble, définir des méthodes, implémenter, définir sur liste, etc.:
Set in Java est une interface qui fait partie de Java Collection Framework et implémente l'interface Collection. Une collection d'ensembles fournit les caractéristiques d'un ensemble mathématique.
Un ensemble peut être défini comme une collection d'objets non ordonnés et ne peut pas contenir de valeurs en double. Comme l'interface set hérite de l'interface Collection, elle implémente toutes les méthodes de l'interface Collection.
=> Consultez le guide de formation Perfect Java ici.
Ce que vous apprendrez:
Ensemble Java
L'interface définie est implémentée par des classes et des interfaces comme indiqué dans le diagramme ci-dessous.
Comme indiqué dans le diagramme ci-dessus, l'interface Set est héritée par les classes, HashSet, TreeSet, LinkedHashSet et EnumSet. Les interfaces SortedSet et NavigableSet implémentent également l'interface Set.
Certaines des caractéristiques importantes de l'interface Set sont données ci-dessous:
- L'interface définie fait partie de Java Collections Framework.
- L'interface définie permet des valeurs uniques.
- Il peut avoir au plus une valeur nulle.
- Java 8 fournit une méthode par défaut pour l'interface définie - Spliterator.
- L'interface définie ne prend pas en charge les index des éléments.
- L'interface définie prend en charge les génériques.
Comment créer un ensemble?
L'interface définie en Java fait partie du package java.util. Pour inclure une interface définie dans le programme, nous devons utiliser l'une des instructions d'importation suivantes.
import java.util.*; ou
import java.util.Set; Une fois que la fonctionnalité d'interface d'ensemble est incluse dans le programme, nous pouvons créer un ensemble en Java en utilisant l'une des classes d'ensemble (classes qui implémentent l'interface d'ensemble) comme indiqué ci-dessous.
Set colors_Set = new HashSet(); Nous pouvons ensuite initialiser cet objet set en lui ajoutant quelques éléments à l'aide de la méthode add.
colors_Set.add(“Red”); colors_Set.add(“Green”); colors_Set.add(“Blue”); Définir l'exemple en Java
Implémentons un exemple simple en Java pour illustrer l'interface Set.
import java.util.*; public class Main { public static void main(String() args) { // Set demo with HashSet Set Colors_Set = new HashSet(); Colors_Set.add('Red'); Colors_Set.add('Green'); Colors_Set.add('Blue'); Colors_Set.add('Cyan'); Colors_Set.add('Magenta'); //print set contents System.out.print('Set contents:'); System.out.println(Colors_Set); // Set demo with TreeSet System.out.print('
Sorted Set after converting to TreeSet:'); Set tree_Set = new TreeSet(Colors_Set); System.out.println(tree_Set); } }Production:
Contenu du jeu: (Rouge, Cyan, Bleu, Magenta, Vert)
Ensemble trié après conversion en TreeSet: (Bleu, Cyan, Vert, Magenta, Rouge)
Itérer à travers l'ensemble en Java
Nous pouvons accéder à chacun des éléments d'un ensemble en utilisant différentes approches. Nous discuterons de ces approches ci-dessous.
Utiliser Iterator
Nous pouvons définir un itérateur pour traverser un objet d'ensemble. En utilisant cet itérateur, nous pouvons accéder à chaque élément de l'ensemble et le traiter.
Le programme Java suivant illustre l'itération dans l'ensemble et imprime les éléments de l'ensemble.
import java.util.*; import java.util.HashSet; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); // Create an iterator for the cities_Set Iterator iter = cities_Set.iterator(); // print the set contents using iterator System.out.println('Values using Iterator: '); while (iter.hasNext()) { System.out.print(iter.next()+ ' '); } } }Production:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Valeurs utilisant Iterator:
Bangalore Pune Kolkata Hyderabad
Utilisation de la boucle For-each
Nous pouvons également utiliser la boucle for-each pour accéder aux éléments d'un ensemble. Ici, nous parcourons l'ensemble en boucle.
Le programme suivant le démontre.
import java.util.*; import java.util.HashSet; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); System.out.println('
Set contents using forEach loop:'); // print the set contents using forEach loop for(String val : cities_Set) { System.out.print(val + ' '); } } } Production:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Définissez le contenu à l'aide de la boucle forEach:
Bangalore Pune Kolkata Hyderabad
Utilisation de l'API Java 8 Stream
Nous pouvons également itérer et accéder aux éléments d'ensemble à l'aide de l'API de flux Java 8. En cela, nous générons un flux à partir d'un ensemble, puis nous itérons dans le flux en utilisant la boucle forEach.
Le programme Java ci-dessous illustre l'itération de l'ensemble à l'aide de l'API de flux Java 8.
import java.util.*; import java.util.HashSet; import java.util.stream.*; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); System.out.println('
Set contents using Java 8 stream API:'); //generate a stream from set Stream stream = cities_Set.stream(); //iterate the stream using forEach loop to print the elements stream.forEach((element) -> { System.out.print(element + ' '); }); } }Production:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Définissez le contenu à l'aide de l'API de flux Java 8:
Bangalore Pune Kolkata Hyderabad
Définir l'API de méthodes
Vous trouverez ci-dessous les méthodes prises en charge par l'interface Set. Ces méthodes effectuent des opérations de base comme ajouter, supprimer, contient, etc. avec les autres opérations.
l'adresse IP de la passerelle spécifiée n'est pas valide
| Méthode | Prototype de méthode | La description |
|---|---|---|
| est vide | booléen isEmpty () | Vérifie si l'ensemble est vide |
| ajouter | booléen ajouter (E e) | Ajoute l'élément e à l'ensemble s'il n'est pas présent dans l'ensemble |
| tout ajouter | booléen addAll (Collection c) | Ajoute l'élément de la collection c à l'ensemble. |
| supprimer | boolean remove (objet o) | Supprime l'élément o donné de l'ensemble. |
| Enlever tout | booléen removeAll (Collection c) | Supprime les éléments présents dans la collection donnée c de l'ensemble. |
| contient | boolean contient (Object o) | Vérifie si l'élément o donné est présent dans l'ensemble. Renvoie vrai si oui. |
| contientTout | booléen contientAll (Collection c) | Vérifie si l'ensemble contient tous les éléments de la collection spécifiée; Renvoie vrai si oui. |
| retenirTout | booléen retentionAll (Collection c) | L'ensemble conserve tous les éléments de la collection donnée c |
| dégager | vide clair () | Efface l'ensemble en supprimant tous les éléments de l'ensemble |
| itérateur | Itérateur itérateur () | Utilisé pour obtenir l'itérateur de l'ensemble |
| toArray | Object () toArray () | Convertit l'ensemble en représentation sous forme de tableau qui contient tous les éléments de l'ensemble. |
| Taille | taille int () | Renvoie le nombre total d'éléments ou la taille de l'ensemble. |
| hashCode | hashCode () | Renvoie le hashCode de l'ensemble. |
Maintenant, implémentons certaines des méthodes que nous avons discutées ci-dessus dans un programme Java. Nous verrons également les opérations spécifiques suivantes qui impliquent deux ensembles.
Définir l'implémentation en Java
Intersection: Nous conservons des valeurs communes entre les deux ensembles. Nous effectuons une intersection en utilisant le retenirTout méthode.
Syndicat: Ici, nous combinons les deux ensembles. Ceci est fait avec le tout ajouter méthode.
Différence: Cette opération supprime un ensemble de l'autre. Cette opération est effectuée à l'aide du Enlever tout méthode.
import java.util.*; public class Main { public static void main(String args()) { //declare a set class (HashSet) Set numSet = new HashSet(); //add an element => add numSet.add(13); //add a list to the set using addAll method numSet.addAll(Arrays.asList(new Integer() {1,6,4,7,3,9,8,2,12,11,20})); //print the set System.out.println('Original Set (numSet):' + numSet); //size() System.out.println('
numSet Size:' + numSet.size()); //create a new set class and initialize it with list elements Set oddSet = new HashSet(); oddSet.addAll(Arrays.asList(new Integer() {1, 3, 7, 5, 9})); //print the set System.out.println('
OddSet contents:' + oddSet); //contains () System.out.println('
numSet contains element 2:' + numSet.contains(3)); //containsAll () System.out.println('
numSet contains collection oddset:' + numSet.containsAll(oddSet)); // retainAll () => intersection Set set_intersection = new HashSet(numSet); set_intersection.retainAll(oddSet); System.out.print('
Intersection of the numSet & oddSet:'); System.out.println(set_intersection); // removeAll () => difference Set set_difference = new HashSet(numSet); set_difference.removeAll(oddSet); System.out.print('Difference of the numSet & oddSet:'); System.out.println(set_difference); // addAll () => union Set set_union = new HashSet(numSet); set_union.addAll(oddSet); System.out.print('Union of the numSet & oddSet:'); System.out.println(set_union); } }Production:
Jeu d'originaux (numSet): (1, 2, 3, 4, 20, 6, 7, 8, 9, 11, 12, 13)
numSet Taille: 12
Contenu OddSet: (1, 3, 5, 7, 9)
numSet contient l'élément 2: true
numSet contient une collection oddset: false
Intersection du numSet et oddSet: (1, 3, 7, 9)
Différence entre numSet et oddSet: (2, 4, 6, 8, 11, 12, 13, 20)
Union du numSet & oddSet: (1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 20)
Définir sur tableau
Nous avons vu la méthode «toArray» dans la section ci-dessus sur les méthodes. Cette méthode toArray peut être utilisée pour convertir l'ensemble en Array.
Le programme Java ci-dessous convertit l'ensemble en un tableau.
import java.util.*; public class Main { public static void main(String() args) { //declare a set class (HashSet) Set setOfColors= new HashSet(); // add data to HashSet setOfColors.add('Red'); setOfColors.add('Green'); setOfColors.add('Blue'); setOfColors.add('Cyan'); setOfColors.add('Magenta'); //print the set System.out.println('The set contents:' + setOfColors); //convert Set to Array using toArray () method String colors_Array() = setOfColors.toArray(new String(setOfColors.size())); //print the Array System.out.println('Set converted to Array:' + Arrays.toString(colors_Array)); } }Production:
Le contenu de l'ensemble: (Rouge, Cyan, Bleu, Magenta, Vert)
Ensemble converti en matrice: (Rouge, Cyan, Bleu, Magenta, Vert)
Tableau à définir
Pour convertir un tableau en un ensemble en Java, nous pouvons suivre deux approches comme indiqué ci-dessous.
#1) Nous pouvons convertir le tableau en liste à l'aide de la méthode asList, puis passer cette liste en tant qu'argument au constructeur d'ensemble. Cela entraîne la création de l'objet set avec les éléments du tableau.
#deux) Alternativement, nous pouvons utiliser la méthode Collections.addAll pour copier les éléments du tableau dans l'objet set.
Le programme Java ci-dessous implémente ces deux approches pour convertir un tableau en set.
import java.util.*; public class Main { public static void main(String() args) { //declare an array Integer() numArray = {10,50,40,20,60,30,80,70}; System.out.println('The input array:' + Arrays.toString(numArray)); //Approach 1: create a set class and provide array //converted to list as constructor arg Set numSet = new HashSet(Arrays.asList(numArray)); //print the set System.out.println('
Array converted to set through asList:' + numSet); //create another set Set intSet = new HashSet(); //Approach 2: use Collections.addAll method to copy array elements to the set Collections.addAll(intSet, numArray); //print the set System.out.println('
Array converted to set using Collections.addAll:' + intSet); } }Production:
comment définir les fichiers jar à ouvrir avec java
Le tableau d'entrée: (10, 50, 40, 20, 60, 30, 80, 70)
Tableau converti en ensemble via asList: (80, 50, 20, 70, 40, 10, 60, 30)
Tableau converti en ensemble à l’aide de Collections.addAll: (80, 50, 20, 70, 40, 10, 60, 30)
Définir dans la liste
Pour convertir un ensemble en liste en Java, nous pouvons utiliser la méthode ‘addAll’ de la classe list. Cette méthode copie le contenu de l'ensemble ou de toute collection fournie en tant qu'argument dans la liste qui appelle la méthode addAll.
Le programme Java ci-dessous convertit l'ensemble en ArrayList.
import java.util.*; public class Main { public static void main(String() args) { //declare a set class and initialize it Set strSet= new HashSet(); strSet.add('one'); strSet.add('two'); strSet.add('three'); strSet.add('four'); strSet.add('five'); //print the set System.out.println('The set contents: ' + strSet); //declare an ArrayList List strList = new ArrayList(); //using addAll method,copy set elements to ArrayList strList.addAll(strSet); //print the ArrayList System.out.println('The ArrayList from set : ' + strList); } }Production:
Le contenu de l'ensemble: (quatre, un, deux, trois, cinq)
ArrayList de l'ensemble: (quatre, un, deux, trois, cinq)
Liste à définir
Pour convertir la liste donnée comme ArrayList en un ensemble en Java, nous passons l'objet de liste en tant qu'argument au constructeur de l'ensemble.
Le programme Java suivant implémente cette conversion.
import java.util.*; public class Main { public static void main(String() args) { //declare an ArrayList and initialize it List strList = new ArrayList(); strList.add('one'); strList.add('two'); strList.add('three'); strList.add('four'); strList.add('five'); //print the ArrayList System.out.println('The ArrayList: ' + strList); //declare a set class with ArrayList as argument to the constructor Set strSet= new HashSet(strList); //print the set System.out.println('The Set obtained from ArrayList: ' + strSet); } }Production:
ArrayList: (un, deux, trois, quatre, cinq)
L'ensemble obtenu à partir de ArrayList: (quatre, un, deux, trois, cinq)
Trier un ensemble en Java
La collection Set en Java n'a pas de méthode directe de tri. Nous devons donc suivre des approches indirectes pour trier ou ordonner le contenu de l'objet d'ensemble. Cependant, il existe une exception dans le cas où l'objet set est un TreeSet.
L'objet TreeSet fournit par défaut l'ensemble ordonné. Par conséquent, si nous tenons à l'ensemble ordonné des éléments, nous devrions opter pour TreeSet. Pour HashSet ou des objets LinkedHashSet, nous pouvons convertir l'ensemble en List. Triez la liste à l'aide de la méthode Collections.sort (), puis reconvertissez la liste en set.
Cette approche est illustrée dans le programme Java ci-dessous.
import java.util.Arrays; import java.util.Collections; import java.util.*; public class Main{ public static void main(String() args) { //Declare a set and initialize it with unsorted list HashSet evenNumSet = new LinkedHashSet( Arrays.asList(4,8,6,2,12,10,62,40,36) ); //print the unsorted set System.out.println('Unsorted Set: ' + evenNumSet); //convert set to list List numList = new ArrayList(evenNumSet); //Sort the list using Collections.sort () method Collections.sort(numList); //convert set to list evenNumSet = new LinkedHashSet(numList); //convert list to set //Print the sorted set System.out.println('Sorted Set:' + evenNumSet); } }Production:
Ensemble non trié: (4, 8, 6, 2, 12, 10, 62, 40, 36)
Ensemble trié: (2, 4, 6, 8, 10, 12, 36, 40, 62)
List Vs Set en Java
Discutons de certaines des différences entre une liste et un ensemble.
| liste | Ensemble |
|---|---|
| Les valeurs nulles sont autorisées. | Une seule valeur nulle autorisée. |
| Interface de liste d'outils. | Interface de jeu d'outils. |
| Contient une classe Legacy, Vector. | Pas de classes héritées. |
| ArrayList, LinkedList sont des implémentations d'interface de liste. | HashSet, TreeSet, LinkedHashSet sont des implémentations Set. |
| Une séquence ordonnée d'éléments. | Une collection non ordonnée d'éléments distincts. |
| Permet les doublons. | Aucun doublon n'est autorisé. |
| Capable d'accéder aux éléments selon la position de l'élément. | Aucun accès positionnel. |
| Nouvelles méthodes définies dans une interface List. | Aucune nouvelle méthode définie dans l'interface Set. Les méthodes d'interface de collection doivent être utilisées avec les sous-classes Set. |
| Peut être parcouru dans le sens avant et arrière à l'aide de ListIterator. | Il ne peut être parcouru que dans le sens avant avec Iterator. |
Questions fréquemment posées
Q # 1) Qu'est-ce qu'un ensemble en Java?
Répondre: Un ensemble est une collection non ordonnée d'éléments uniques et modélise généralement le concept d'ensemble en mathématiques.
Set est une interface qui étend l'interface de collection. Il contient les méthodes dont il hérite de l'interface Collection. L'interface définie n'ajoute qu'une restriction, c'est-à-dire qu'aucun doublon ne doit être autorisé.
Q # 2)L'ensemble est-il commandé en Java?
Répondre: Le jeu Java n'est pas commandé. Il ne fournit pas non plus un accès positionnel.
Q # 3)Un ensemble peut-il contenir des doublons?
Répondre: Un ensemble est une collection d'éléments uniques, il ne peut pas avoir de doublons.
Q # 4)Java Set est-il itérable?
Répondre: Oui. L'interface set implémente une interface Iterable et donc set peut être parcouru ou itéré à l'aide d'une boucle forEach.
Q # 5)NULL est-il autorisé dans l'ensemble?
Répondre: Un ensemble autorise une valeur nulle, mais au plus une valeur nulle est autorisée dans les implémentations d'ensemble telles que HashSet et LinkedHashSet. Dans le cas de TreeSet, il lève une exception d'exécution si la valeur null est spécifiée.
Conclusion
Dans ce didacticiel, nous avons discuté des concepts généraux et de l'implémentation liés à Set interface en Java.
L'interface set n'a aucune nouvelle méthode définie, mais elle utilise les méthodes de l'interface Collector et ajoute uniquement l'implémentation pour empêcher les valeurs en double. L'ensemble autorise au plus une valeur nulle.
Dans nos didacticiels ultérieurs, nous discuterons des implémentations spécifiques de l'interface Set comme HashSet et TreeSet.
=> Visitez ici pour apprendre Java à partir de zéro.
lecture recommandée
- Tutoriel de réflexion Java avec des exemples
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- Tutoriel sur la méthode Java String contains () avec des exemples
- Jagged Array In Java - Tutoriel avec des exemples
- Tutoriel de classe de scanner Java avec des exemples
- Tutoriel Java Array Length avec des exemples de code
- Tutoriel Java String | Méthodes de chaîne Java avec exemples
- Qu'est-ce que le vecteur Java | Tutoriel de classe vectorielle Java avec des exemples