Java Language
Ensembles

Déclarer un HashSet avec des valeurs

Vous pouvez créer une nouvelle classe qui hérite de HashSet:

Set<String> h = new HashSet<String>() {{
    add("a");
    add("b");
}};

Une solution en ligne:

Set<String> h = new HashSet<String>(Arrays.asList("a", "b"));

En utilisant goyave:

Sets.newHashSet("a", "b", "c")

Utiliser des flux:

Set<String> set3 = Stream.of("a", "b", "c").collect(toSet());

Types et utilisation des ensembles

Généralement, les ensembles sont un type de collection qui stocke des valeurs uniques. L'unicité est déterminée par les méthodes equals() et hashCode() .

Le tri est déterminé par le type de set.

HashSet - Tri aléatoire

Set<String> set = new HashSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Strawberry", "Banana", "Apple"]

LinkedHashSet - Ordre d'insertion

Set<String> set = new LinkedHashSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Banana", "Apple", "Strawberry"]

TreeSet - Par compareTo() ou Comparator

Set<String> set = new TreeSet<> ();
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Apple", "Banana", "Strawberry"]

Set<String> set = new TreeSet<> ((string1, string2) -> string2.compareTo(string1));
set.add("Banana");
set.add("Banana");
set.add("Apple");
set.add("Strawberry");

// Set Elements: ["Strawberry", "Banana", "Apple"]

Initialisation

Un ensemble est une collection qui ne peut pas contenir d'éléments en double. Il modélise l'abstraction d'ensemble mathématique.

Set a son implémentation dans différentes classes comme HashSet , TreeSet , LinkedHashSet .

Par exemple:

HashSet:

Set<T> set = new HashSet<T>();

Ici, T peut être String , Integer ou tout autre objet . HashSet permet une recherche rapide de O (1) mais ne trie pas les données ajoutées et perd l'ordre d'insertion des éléments.

TreeSet:

Il stocke les données de manière triée en sacrifiant une certaine vitesse pour les opérations de base qui prennent O (lg (n)). Il ne conserve pas l'ordre d'insertion des éléments.

TreeSet<T> sortedSet = new TreeSet<T>();

LinkedHashSet:

C'est une implémentation de liste HashSet de HashSet Once qui peut parcourir les éléments dans l'ordre dans HashSet ils ont été ajoutés. Le tri n'est pas prévu pour son contenu. O (1) opérations de base sont fournies, mais il y a un coût plus élevé que HashSet dans la HashSet de la liste des liens de support.

LinkedHashSet<T> linkedhashset = new LinkedHashSet<T>();

Bases de Set

Qu'est-ce qu'un ensemble?

Un ensemble est une structure de données qui contient un ensemble d'éléments ayant une propriété importante indiquant que deux éléments de l'ensemble ne sont pas égaux.

Types de set:

1. HashSet: Un jeu sauvegardé par une table de hachage (en fait une instance de HashMap)
2. HashSet lié: un jeu sauvegardé par une table de hachage et une liste chaînée, avec un ordre d'itération prévisible
3. TreeSet: Une implémentation NavigableSet basée sur un TreeMap.

Créer un ensemble

Set<Integer> set = new HashSet<Integer>(); // Creates an empty Set of Integers

Set<Integer> linkedHashSet = new LinkedHashSet<Integer>(); //Creates a empty Set of Integers, with predictable iteration order

Ajout d'éléments à un ensemble

Des éléments peuvent être ajoutés à un ensemble en utilisant la méthode add()

 set.add(12); //  - Adds element 12 to the set
 set.add(13); //  - Adds element 13 to the set

Notre set après avoir exécuté cette méthode:

set = [12,13]

Supprimer tous les éléments d'un ensemble

set.clear();  //Removes all objects from the collection.

Après cet ensemble sera:

set = []

Vérifier si un élément fait partie de l'ensemble

L'existence d'un élément dans l'ensemble peut être vérifiée à l'aide de la méthode contains()

set.contains(0);  //Returns true if a specified object is an element within the set.

Sortie: False

Vérifiez si un ensemble est vide

isEmpty() méthode isEmpty() peut être utilisée pour vérifier si un ensemble est vide.

set.isEmpty();  //Returns true if the set has no elements

Sortie: True

Retirer un élément de l'ensemble

 set.remove(0); // Removes first occurrence of a specified object from the collection

Vérifiez la taille de l'ensemble

set.size(); //Returns the number of elements in the collection

Sortie: 0

Créer une liste à partir d'un ensemble existant

Utiliser une nouvelle liste

List<String> list = new ArrayList<String>(listOfElements);

Utiliser la méthode List.addAll ()

    Set<String> set = new HashSet<String>();
    set.add("foo");
    set.add("boo");
    
    List<String> list = new ArrayList<String>();
    list.addAll(set);

Utilisation de l'API Java 8

List<String> list = set.stream().collect(Collectors.toList());

Éliminer les doublons en utilisant Set

Supposons que vous ayez des elements collection et que vous souhaitiez créer une autre collection contenant les mêmes éléments mais avec tous les doublons éliminés :

Collection<Type> noDuplicates = new HashSet<Type>(elements);

Exemple :

List<String> names = new ArrayList<>(
        Arrays.asList("John", "Marco", "Jenny", "Emily", "Jenny", "Emily", "John"));
Set<String> noDuplicates = new HashSet<>(names);
System.out.println("noDuplicates = " + noDuplicates);

Sortie :

noDuplicates = [Marco, Emily, John, Jenny]