CKTIS / Java
Elemente in `Set` und Zyklenerkennung
Prüfe, füge hinzu und entferne Elemente in einem `Set`. Der Rückgabewert von `add` erkennt einen Typ auf dem aktiven Pfad; `finally` entfernt den Eintrag beim Verlassen des Aufrufs.
Version: 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);Bei java.util.Set<E> richtet sich die Zugehörigkeit nach der durch Objects.equals definierten Gleichheit, nicht nach der Position. contains(Object o) liefert true, wenn ein gleiches Element vorhanden ist, und ändert die Menge nicht. add(E e) liefert beim Einfügen true; bei einem Duplikat liefert es false und ändert nichts. remove(Object o) liefert true, wenn es ein gleiches Element entfernt, sonst false. Der Parameter Object bedeutet, dass Prüfen und Entfernen kein Argument vom Typ E erfordern; entfernt wird nach Wert, nicht nach Index.
Einfügen und Entfernen sind optionale Operationen: Eine mit Set.of erzeugte Menge weist sie mit UnsupportedOperationException ab. Je nach Implementierung kann add für null, einen inkompatiblen Typ oder eine unzulässige Elementeigenschaft NullPointerException, ClassCastException bzw. IllegalArgumentException auslösen. Beim Prüfen oder Entfernen eines unzulässigen null oder eines inkompatiblen Typs kann die Implementierung false liefern oder die entsprechende Ausnahme auslösen. Verwende ein veränderbares HashSet mit Schlüsseln, deren equals und hashCode stabil bleiben, solange sie gespeichert sind.
Halte beim rekursiven Durchlaufen von Typabhängigkeiten nur die Typen des aktuellen Pfads in der Menge. !active.add(type) erkennt einen Zyklus ohne vorherigen Aufruf von contains. Entferne den Eintrag im Zykluszweig nicht: Er gehört zu einem früheren Aufruf. Betritt try erst nach erfolgreichem Einfügen und entferne den Eintrag in finally. Dieser Block läuft beim normalen Verlassen, bei return und bei der Weitergabe einer Ausnahme. Die Menge speichert weder die Stapelreihenfolge noch alle je besuchten Typen; ein anderer Zweig kann denselben Typ erneut besuchen.
Beispiele
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);
}
}
}Ergebnis
visit: A visit: B cycle: A visit: C visit: C A active after traversal: false
`B` erkennt den Rücksprung zum aktiven `A`. `C` wird getrennt über `B` und über `A` besucht. Das abschließende `false` bestätigt, dass `A` nicht mehr zum aktiven Pfad gehört.
Zugehörige Lektionen
- Java · Lektion 59 · Fortgeschritten · Version: 2