CKTIS / Java
Lidmaatschap van een `Set` en cyclusdetectie
Controleer, voeg toe en verwijder elementen in een `Set`. Het resultaat van `add` signaleert een type op het actieve pad; `finally` verwijdert het element zodra de aanroep eindigt.
Versie: Java SE 21
Syntax
Java SE 21 — instance methods of java.util.Set<E>:
boolean add(E e);
boolean contains(Object o);
boolean remove(Object o);In java.util.Set<E> hangt lidmaatschap af van gelijkheid volgens Objects.equals, niet van de positie. contains(Object o) geeft true terug als er een gelijk element aanwezig is, zonder de verzameling te wijzigen. add(E e) geeft true terug als het element wordt toegevoegd; bij een duplicaat geeft het false terug en verandert er niets. remove(Object o) geeft true terug als het een gelijk element verwijdert en false als er geen is. Dankzij de parameter Object hoeft het argument bij opzoeken of verwijderen niet van type E te zijn; verwijderen gebeurt op waarde, niet op index.
Toevoegen en verwijderen zijn optionele bewerkingen: een verzameling gemaakt met Set.of weigert ze met UnsupportedOperationException. Afhankelijk van de implementatie kan add bij null, een incompatibel type of een ongeldige eigenschap van het element respectievelijk NullPointerException, ClassCastException of IllegalArgumentException gooien. Bij het opzoeken of verwijderen van een niet-toegestane null of een waarde van een incompatibel type mag de implementatie false teruggeven of de bijbehorende uitzondering gooien. Gebruik een wijzigbare HashSet met sleutels waarvan equals en hashCode stabiel blijven zolang ze in de verzameling zitten.
Houd bij het recursief doorlopen van typeafhankelijkheden alleen de typen op het huidige pad bij. !active.add(type) detecteert een cyclus zonder eerst contains aan te roepen. Verwijder het element niet in de tak die de cyclus detecteert: het hoort bij een eerdere aanroep. Ga pas na een geslaagde toevoeging naar try en verwijder het element in finally. Dat blok wordt uitgevoerd bij normale afloop, bij return en wanneer een uitzondering wordt doorgegeven. De verzameling bewaart noch de volgorde van de aanroepstack, noch alle eerder bezochte typen; een andere tak kan hetzelfde type opnieuw bezoeken.
Voorbeelden
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);
}
}
}Resultaat
visit: A visit: B cycle: A visit: C visit: C A active after traversal: false
`B` detecteert de terugkeer naar het nog actieve `A`. `C` wordt afzonderlijk bezocht via `B` en via `A`. De laatste `false` bevestigt dat `A` niet meer op het actieve pad staat.
Gerelateerde lessen
- Java · Les 59 · Gevorderd · Versie: 2