Nouvelles fonctionnalités

Java LinkedHashSet

Dans ce tutoriel, nous allons apprendre la classe LinkedHashSet de Java et ses méthodes à l'aide d'exemples.

La classe LinkedHashSet du Java Collection Framework fournit les fonctionnalités des structures de données tableau de hachage et liste chaînée.Il implémente.

L'interface SetLes éléments de HashSet sont stockés de manière similaire àdans le tableau de hachage.

Mais, l'ensemble de hachage de liste conserve une double liste chaînée pour tous ses éléments en interne. La liste définit l'ordre d'insertion des éléments dans le tableau de hachage.

Créer un LinkedHashSet

Pour créer un ensemble de hachage de liste, nous devons d'abord importer le paquet java.util.LinkedHashSet.

Après avoir importé le paquet, vous pouvez créer un ensemble de hachage de liste en Java.

//Avec8Une capacité de75Un ensemble de hachage de charge de facteur
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Ici, nous créons un ensemble de hachage de liste nommé numbers.

Attention, la phrase new LinkedHashSet<>(8, 0.75) ici, le premier paramètre estLa capacité, le second paramètre estLe facteur de charge.

• capacity - La capacité de ce ensemble de hachage est8Cela signifie qu'il peut stocker8éléments.

• loadFactor- Le facteur de charge de ce ensemble de hachage est de 0.6Cela signifie que tant que notre tableau de hachage est60%, l'élément se déplace dans un nouveau tableau de hachage, la taille de ce tableau de hachage est deux fois plus grande que celle du tableau de hachage original.

Capacité et facteur de charge par défaut

Nous pouvons créer un hash set lié sans définir sa capacité et son facteur de charge. Par exemple,

//LinkedHashSet avec capacité et facteur de charge par défaut
LinkedHashSet<Integer> numbers1　= new LinkedHashSet<>();

Par défaut,

• La capacité du hash set lié sera16

• Le facteur de charge sera de 0.75

Créer LinkedHashSet à partir d'autres collections

Voici comment nous créons un LinkedHashSet contenant tous les éléments d'autres collections.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer une arrayList d'entiers pairs
　　　　　　　　ArrayList<Integer> evenNumbers = new ArrayList<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("ArrayList: ",　+　evenNumbers);
　　　　　　　　//Créer LinkedHashSet à partir d'ArrayList
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　numbers);
　　　　}
}

Résultat de la sortie

ArrayList: [2,　4]
LinkedHashSet: [2,　4]

Méthodes du LinkedHashSet

La classe LinkedHashSet fournit des méthodes nous permettant d'exécuter diverses opérations sur le hash set lié.

Insérer l'élément dans LinkedHashSet

• add() - Insérer l'élément spécifié dans le hash set de la liste chaînée

• addAll() - Insérer tous les éléments du jeu de collection spécifié dans le hash set de la liste chaînée

Par exemple,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();
　　　　　　　　//　Utilisation de la méthode add()
　　　　　　　　evenNumber.add(2);
　　　　　　　　evenNumber.add(4);
　　　　　　　　evenNumber.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　evenNumber);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　
　　　　　　　　//Utilisation de la méthode addAll()
　　　　　　　　numbers.addAll(evenNumber);
　　　　　　　　numbers.add(5);
　　　　　　　　System.out.println("New LinkedHashSet: ",　+　numbers);
　　　　}
}

Résultat de la sortie

LinkedHashSet: [2,　4,　6]
New LinkedHashSet: [2,　4,　6,　5]

Accès aux éléments du LinkedHashSet

Pour accéder aux éléments du hash set de la liste chaînée, nous pouvons utiliser la méthode iterator(). Pour utiliser cette méthode, nous devons importer le paquet java.util.Iterator. Par exemple,

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　numbers);
　　　　　　　　//Appel à la méthode iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("Utiliser Iterator de LinkedHashSet: ");
　　　　　　　　//Accéder aux éléments
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Résultat de la sortie

LinkedHashSet: [2,　5,　6]
Utiliser LinkedHashSet avec Iterator:　2,　5,　6,

Remarques:

• hasNext() retourne true si la table de hachage liée contient un élément suivant

• next() retourne l'élément suivant de la table de hachage liée

Supprimer l'élément de HashSet

• remove() - Supprimer l'élément spécifié de la table de hachage de la liste chaînée

• removeAll() - Supprimer tous les éléments de la table de hachage de la liste chaînée

Par exemple,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ",　+　numbers);
　　　　　　　　//Utiliser la méthode remove()
　　　　　　　　boolean value1　= numbers.remove(5);
　　　　　　　　System.out.println("5A-t-il été supprimé? "　+　value1);
　　　　　　　　boolean value2　= numbers.removeAll(numbers);
　　　　　　　　System.out.println("Est-ce que tous les éléments ont été supprimés? ",　+　value2);
　　　　}
}

Résultat de la sortie

LinkedHashSet: [2,　5,　6]
5A-t-il été supprimé? true
Est-ce que tous les éléments ont été supprimés? true

Méthodes d'opération LinkedHashSet

Les différentes méthodes de la classe LinkedHashSet peuvent également être utilisées pour exécuter diverses opérations sur les ensembles.

l'union

Pour exécuter l'union entre deux ensembles, nous pouvons utiliser la méthode addAll(). Par exemple,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　evenNumbers);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　numbers);
　　　　　　　　//l'union des deux ensembles
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("l'union: ",　+　numbers);
　　　　}
}

Résultat de la sortie

LinkedHashSet1:　[2,　4]
LinkedHashSet2:　[1,　3]
l'union: [1,　3,　2,　4]

intersection

Pour exécuter l'intersection entre deux ensembles, nous pouvons utiliser la méthode retainAll(). Par exemple,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　primeNumbers);
　　　　　　　　LinkedHashSet<Integer> evenNumbers = new LinkedHashSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　evenNumbers);
　　　　　　　　//l'intersection des ensembles
　　　　　　　　evenNumbers.retainAll(primeNumbers);
　　　　　　　　System.out.println("l'intersection des ensembles: ",　+　evenNumbers);
　　　　}
}

Résultat de la sortie

LinkedHashSet1:　[2,　3]
LinkedHashSet2:　[2,　4]
l'intersection des ensembles: [2]

différence d'ensembles

Pour calculer la différence entre deux ensembles, nous pouvons utiliser la méthode removeAll(). Par exemple,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　primeNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　primeNumbers);
　　　　　　　　LinkedHashSet<Integer> oddNumbers = new LinkedHashSet<>();
　　　　　　　　oddNumbers.add(1);
　　　　　　　　oddNumbers.add(3);
　　　　　　　　oddNumbers.add(5);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　oddNumbers);
　　　　　　　　//LinkedHashSet1et LinkedHashSet2La différence entre
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Différence de ensemble: ",　+　primeNumbers);
　　　　}
}

Résultat de la sortie

LinkedHashSet1:　[2,　3,　5]
LinkedHashSet2:　[1,　3,　5]
Différence de ensemble: [2]

Sous-ensemble

Pour vérifier si un ensemble est un sous-ensemble d'un autre ensemble, nous pouvons utiliser la méthode containsAll(). Par exemple,

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("LinkedHashSet1: "　+　numbers);
　　　　　　　　LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("LinkedHashSet2: "　+　primeNumbers);
　　　　　　　　//Vérifier si primeNumbers est un sous-ensemble de numbers
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("LinkedHashSet2C'est LinkedHashSet1Est-ce un sous-ensemble? "　+　result);
　　　　}
}

Résultat de la sortie

LinkedHashSet1:　[1,　2,　3,　4]
LinkedHashSet2:　[2,　3]
LinkedHashSet2C'est LinkedHashSet1Est-ce un sous-ensemble? true

Autres méthodes de LinkedHashSet

Les différences entre LinkedHashSet et HashSet

LinkedHashSet et HashSet implémentent l'interface Set. Mais, ils existent des différences entre eux.

• LinkedHashSet maintains an internal linked list. Therefore, it maintains the insertion order of its elements.

• LinkedHashSet class requires more storage space than HashSet. This is because LinkedHashSet maintains a linked list internally.

• LinkedHashSet is slower in performance than HashSet. This is because there is a linked list in LinkedHashSet.

Differences between LinkedHashSet and TreeSet

The following are the main differences between LinkedHashSet and TreeSet:

• The TreeSet class implements the SortedSet interface. This is why the elements in the tree set are ordered. However, the LinkedHashSet class only maintains the insertion order of its elements.

• TreeSet is usually slower than LinkedHashSet. This is because it must perform a sorting operation every time an element is added to TreeSet.

• LinkedHashSet allows insertion of null values. However, we cannot insert null values into TreeSet.