Guide de débutant sur l'interface SortedSet en Java

Salut à toi, futur(e) magicien(ne) Java ! Aujourd'hui, nous allons entreprendre un voyage passionnant à la découverte de l'interface SortedSet de Java. Ne t'inquiète pas si tu es nouveau dans le monde de la programmation - je serai ton guide amical, et nous explorerons ce sujet pas à pas. Alors, prends ton bâton magique virtuel (ou ton clavier) et plongeons dedans !

Java - SortedSet Interface

Qu'est-ce que l'interface SortedSet ?

Imaginons que tu as une collection de créatures magiques et que tu veux les maintenir dans un ordre spécifique. C'est exactement ce que fait un SortedSet en Java ! C'est comme une étagère spéciale qui arrange automatiquement tes éléments dans un ordre trié.

L'interface SortedSet étend l'interface Set, ce qui signifie qu'elle hérite de toutes les propriétés d'un Set (pas d'éléments en double autorisés), mais avec un superpouvoir en plus - elle garde tout en ordre !

Caractéristiques clés de SortedSet

Éléments triés : Tous les éléments sont stockés dans un ordre trié.
Pas de duplicates : Comme un Set régulier, les duplicates ne sont pas autorisés.
Éléments null : La plupart des implémentations n'autorisent pas les éléments null (avec TreeSet en tant qu'exception notable).

Créer un SortedSet

Commençons par créer notre premier SortedSet. Nous utiliserons la classe TreeSet, qui est l'implémentation la plus courante de SortedSet.

import java.util.SortedSet;
import java.util.TreeSet;

public class MagicalCreatures {
public static void main(String[] args) {
SortedSet<String> creatures = new TreeSet<>();

creatures.add("Dragon");
creatures.add("Unicorn");
creatures.add("Phoenix");
creatures.add("Griffin");

System.out.println("Nos créatures magiques : " + creatures);
}
}

Lorsque tu exécuteras ce code, tu verras :

Nos créatures magiques : [Dragon, Griffin, Phoenix, Unicorn]

Note comment nos créatures sont automatiquement triées en ordre alphabétique. C'est comme si elles s'étaient alignées toutes seules !

Méthodes de l'interface SortedSet

L'interface SortedSet fournit plusieurs méthodes utiles. Jetons un œil à quelques-unes :

Méthode	Description
`first()`	Retourne le premier (le plus bas) élément
`last()`	Retourne le dernier (le plus haut) élément
`headSet(E toElement)`	Retourne une vue de la portion du set strictement inférieure à toElement
`tailSet(E fromElement)`	Retourne une vue de la portion du set supérieure ou égale à fromElement
`subSet(E fromElement, E toElement)`	Retourne une vue de la portion du set de fromElement (inclus) à toElement (exclus)

Voyons ces méthodes en action :

SortedSet<String> creatures = new TreeSet<>();
creatures.add("Dragon");
creatures.add("Unicorn");
creatures.add("Phoenix");
creatures.add("Griffin");

System.out.println("Première créature : " + creatures.first());
System.out.println("Dernière créature : " + creatures.last());
System.out.println("Créatures avant Phoenix : " + creatures.headSet("Phoenix"));
System.out.println("Créatures à partir de Phoenix : " + creatures.tailSet("Phoenix"));
System.out.println("Créatures entre Griffin et Phoenix : " + creatures.subSet("Griffin", "Phoenix"));

Sortie :

Première créature : Dragon
Dernière créature : Unicorn
Créatures avant Phoenix : [Dragon, Griffin]
Créatures à partir de Phoenix : [Phoenix, Unicorn]
Créatures entre Griffin et Phoenix : [Griffin]

N'est-ce pas incroyable comment nous pouvons facilement découper notre set trié ?

Opérations sur l'interface SortedSet

Maintenant, regardons quelques opérations courantes que nous pouvons effectuer sur un SortedSet.

Ajouter des éléments

Nous avons déjà vu comment ajouter des éléments en utilisant la méthode add(). Mais que se passe-t-il si nous essayons d'ajouter un duplicat ?

SortedSet<String> creatures = new TreeSet<>();
creatures.add("Dragon");
creatures.add("Unicorn");
boolean added = creatures.add("Dragon");
System.out.println("Dragon a-t-il été ajouté à nouveau ? " + added);
System.out.println("Nos créatures : " + creatures);

Sortie :

Dragon a-t-il été ajouté à nouveau ? false
Nos créatures : [Dragon, Unicorn]

Comme tu peux le voir, le duplicat "Dragon" n'a pas été ajouté, et notre set reste inchangé.

Supprimer des éléments

Supprimer des éléments est tout aussi simple :

creatures.remove("Unicorn");
System.out.println("Après avoir supprimé Unicorn : " + creatures);

Sortie :

Après avoir supprimé Unicorn : [Dragon]

Vérifier la présence d'éléments

Nous pouvons vérifier si un élément existe dans notre SortedSet :

System.out.println("Avons-nous un Dragon ? " + creatures.contains("Dragon"));
System.out.println("Avons-nous un Unicorn ? " + creatures.contains("Unicorn"));

Sortie :

Avons-nous un Dragon ? true
Avons-nous un Unicorn ? false

Avantages de l'interface SortedSet

Tri automatique : Les éléments sont toujours en ordre, te épargnant la tâche du tri manuel.
Recherche rapide : Parce que les éléments sont triés, la recherche peut être très efficace.
Opérations de vue de plage : Les méthodes headSet(), tailSet(), et subSet() offrent des moyens puissants de travailler avec des portions du set.

Inconvénients de l'interface SortedSet

Performance : Maintenir l'ordre peut être plus lent pour de grands sets par rapport aux sets non triés.
Implémentations limitées : Il y a moins d'implémentations de SortedSet par rapport aux Sets réguliers.

Un exemple amusant : les niveaux de pouvoir des créatures magiques

Terminons avec un exemple plus complexe. Nous allons créer un SortedSet de créatures magiques, mais cette fois, nous les trions par leur niveau de pouvoir !

import java.util.*;

class MagicalCreature implements Comparable<MagicalCreature> {
String name;
int powerLevel;

MagicalCreature(String name, int powerLevel) {
this.name = name;
this.powerLevel = powerLevel;
}

@Override
public int compareTo(MagicalCreature other) {
return Integer.compare(this.powerLevel, other.powerLevel);
}

@Override
public String toString() {
return name + " (Pouvoir : " + powerLevel + ")";
}
}

public class MagicalCreaturePowerRanking {
public static void main(String[] args) {
SortedSet<MagicalCreature> powerRanking = new TreeSet<>();

powerRanking.add(new MagicalCreature("Dragon", 100));
powerRanking.add(new MagicalCreature("Unicorn", 50));
powerRanking.add(new MagicalCreature("Phoenix", 80));
powerRanking.add(new MagicalCreature("Griffin", 70));

System.out.println("Classement des créatures magiques par pouvoir :");
for (MagicalCreature creature : powerRanking) {
System.out.println(creature);
}
}
}

Sortie :

Classement des créatures magiques par pouvoir :
Unicorn (Pouvoir : 50)
Griffin (Pouvoir : 70)
Phoenix (Pouvoir : 80)
Dragon (Pouvoir : 100)

Dans cet exemple, nous avons créé une classe MagicalCreature qui implémente l'interface Comparable. Cela nous permet de définir comment nos créatures doivent être triées (par leur niveau de pouvoir). Le SortedSet utilise ensuite cette information pour maintenir nos créatures en ordre du moins puissant au plus puissant.

Et voilà, jeunes apprentis Java ! Tu viens de maîtriser les bases de l'interface SortedSet. Souviens-toi, la pratique rend parfait, donc n'hesite pas à expérimenter avec ces concepts. Qui sait ? Peut-être que tu créeras le prochain grand système de gestion des créatures magiques ! Jusqu'à la prochaine fois, continue de coder et reste magique ! ?‍♂️✨

Credits: Image by storyset

Tutoriel précédent:

Java - Interface Set

Tutoriel suivant:

Java - Structures de données