CKTIS / Java
Členstvo v množine `Set` a detekcia cyklov
Overuj prítomnosť prvkov v `Set`, pridávaj ich a odstraňuj. Výsledok `add` odhalí typ na aktívnej ceste a `finally` odstráni záznam pri ukončení volania.
Verzia: 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);V java.util.Set<E> závisí členstvo od rovnosti prvkov podľa Objects.equals, nie od pozície. contains(Object o) vráti true, ak množina obsahuje rovnaký prvok, a množinu nemení. add(E e) vráti true, keď prvok vloží; pri duplikáte vráti false a nič nezmení. remove(Object o) vráti true, keď odstráni rovnaký prvok, a false, ak taký prvok nie je prítomný. Parameter Object znamená, že vyhľadávanie ani odstraňovanie nevyžaduje argument typu E; odstraňuje sa podľa hodnoty, nie podľa indexu.
Vkladanie a odstraňovanie sú voliteľné operácie: množina vytvorená pomocou Set.of ich odmietne výnimkou UnsupportedOperationException. Podľa implementácie môže add odmietnuť null výnimkou NullPointerException, nekompatibilný typ výnimkou ClassCastException a neprípustnú vlastnosť prvku výnimkou IllegalArgumentException. Pri vyhľadávaní alebo odstraňovaní nepovoleného null či hodnoty nekompatibilného typu môže implementácia vrátiť false alebo vyvolať príslušnú výnimku. Použi modifikovateľný HashSet s kľúčmi, ktorých equals a hashCode zostávajú počas uloženia stabilné.
Pri rekurzívnom prechádzaní závislostí medzi typmi udržiavaj v množine iba typy z aktuálnej cesty. !active.add(type) odhalí cyklus bez predchádzajúceho volania contains. Vo vetve, ktorá odhalí cyklus, záznam neodstraňuj: patrí skoršiemu volaniu. Do try vstúp až po úspešnom vložení a záznam odstráň vo finally, ktoré sa vykoná pri bežnom opustení bloku, pri return aj pri šírení výnimky. Množina neuchováva poradie zásobníka ani všetky navštívené typy; iná vetva môže rovnaký typ navštíviť znova.
Príklady
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);
}
}
}Výsledok
visit: A visit: B cycle: A visit: C visit: C A active after traversal: false
`B` odhalí návrat k stále aktívnemu `A`. Typ `C` sa navštívi samostatne cez `B` a cez `A`. Záverečné `false` potvrdzuje, že `A` už nie je na aktívnej ceste.
Súvisiace lekcie
- Java · Lekcia 59 · Pokročilá · Verzia: 2