Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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

Sources