CKTIS / Java
Appartenance à un `Set` et détection de cycles
Testez la présence d’un élément dans un `Set`, ajoutez-le ou retirez-le. Le résultat de `add` signale un type déjà sur le chemin actif, et `finally` retire l’entrée à la sortie de l’appel.
Version : Java SE 21
Syntaxe
Java SE 21 — instance methods of java.util.Set<E>:
boolean add(E e);
boolean contains(Object o);
boolean remove(Object o);Dans java.util.Set<E>, l’appartenance dépend de l’égalité définie par Objects.equals, et non de la position. contains(Object o) renvoie true si un élément égal est présent, sans modifier l’ensemble. add(E e) renvoie true lors de l’insertion ; pour un doublon, il renvoie false sans rien changer. remove(Object o) renvoie true s’il retire un élément égal et false s’il n’y en a pas. Le paramètre Object signifie que la recherche et le retrait n’exigent pas un argument de type E ; le retrait se fait par valeur, non par indice.
L’insertion et le retrait sont des opérations facultatives : un ensemble créé par Set.of les refuse avec UnsupportedOperationException. Selon l’implémentation, add peut refuser null, un type incompatible ou une propriété d’élément non autorisée en levant respectivement NullPointerException, ClassCastException ou IllegalArgumentException. Lors d’un test de présence ou d’un retrait avec un null interdit ou un type incompatible, l’implémentation peut renvoyer false ou lever l’exception correspondante. Utilisez un HashSet modifiable avec des clés dont equals et hashCode restent stables tant qu’elles y figurent.
Lors du parcours récursif de dépendances entre types, ne gardez dans l’ensemble que les types du chemin courant. !active.add(type) détecte un cycle sans appel préalable à contains. Ne retirez pas l’entrée dans la branche qui détecte le cycle : elle appartient à un appel antérieur. Entrez dans try seulement après une insertion réussie et retirez l’entrée dans finally, qui s’exécute à la sortie normale, lors d’un return ou lors de la propagation d’une exception. L’ensemble ne conserve ni l’ordre de la pile ni tous les types déjà visités ; une autre branche peut revisiter le même type.
Exemples
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class SetMembershipDemo {
private static final class A {}
private static final class B {}
private static final class C {}
private static final Map<Class<?>, List<Class<?>>> DEPENDENCIES = Map.of(
A.class, List.of(B.class, C.class),
B.class, List.of(A.class, C.class)
);
public static void main(String[] args) {
Set<Class<?>> active = new HashSet<>();
visit(A.class, active);
System.out.println("A active after traversal: " + active.contains(A.class));
}
private static void visit(Class<?> type, Set<Class<?>> active) {
if (!active.add(type)) {
System.out.println("cycle: " + type.getSimpleName());
return;
}
try {
System.out.println("visit: " + type.getSimpleName());
for (Class<?> dependency : DEPENDENCIES.getOrDefault(type, List.of())) {
visit(dependency, active);
}
} finally {
active.remove(type);
}
}
}Résultat
visit: A visit: B cycle: A visit: C visit: C A active after traversal: false
`B` détecte le retour vers `A`, encore actif. `C` est visité séparément via `B` puis via `A`. Le dernier `false` confirme que `A` ne figure plus sur le chemin actif.
Leçons associées
- Java · Leçon 59 · Avancé · Version : 2