CKTIS / Java
Pripadnost skupu `Set` i otkrivanje ciklusa
Provjeravaj pripadnost skupu `Set`, dodaj elemente i uklanjaj ih. Rezultat metode `add` otkriva tip koji je već na aktivnom putu, a `finally` uklanja zapis pri izlasku iz poziva.
Verzija: Java SE 21
Sintaksa
Java SE 21 — instance methods of java.util.Set<E>:
boolean add(E e);
boolean contains(Object o);
boolean remove(Object o);U java.util.Set<E> pripadnost se temelji na jednakosti prema Objects.equals, a ne na položaju. contains(Object o) vraća true ako je prisutan jednak element i ne mijenja skup. add(E e) vraća true kad umetne element; za duplikat vraća false i ne mijenja skup. remove(Object o) vraća true ako ukloni jednak element i false ako takvog elementa nema. Parametar Object znači da provjera i uklanjanje ne zahtijevaju argument tipa E; uklanjanje se obavlja po vrijednosti, ne po indeksu.
Umetanje i uklanjanje neobavezne su operacije: skup stvoren pomoću Set.of odbija ih uz UnsupportedOperationException. Ovisno o implementaciji, add može odbiti null, nekompatibilan tip ili nedopušteno svojstvo elementa iznimkom NullPointerException, ClassCastException odnosno IllegalArgumentException. Pri provjeri ili uklanjanju nedopuštenog null ili vrijednosti nekompatibilnog tipa implementacija može vratiti false ili baciti odgovarajuću iznimku. Upotrijebi promjenjivi HashSet s ključevima čiji equals i hashCode ostaju stabilni dok su u skupu.
Pri rekurzivnom obilasku ovisnosti među tipovima u skupu drži samo tipove s trenutačnog puta. !active.add(type) otkriva ciklus bez prethodnog poziva metode contains. Nemoj ukloniti zapis u grani koja otkrije ciklus: pripada ranijem pozivu. Uđi u try tek nakon uspješnog umetanja i ukloni zapis u finally, koji se izvršava pri uobičajenom izlasku, pri return i pri propagiranju iznimke. Skup ne čuva redoslijed stoga ni sve dosad posjećene tipove; druga grana može ponovno posjetiti isti tip.
Primjeri
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);
}
}
}Rezultat
visit: A visit: B cycle: A visit: C visit: C A active after traversal: false
`B` otkriva povratak na još uvijek aktivni `A`. Tip `C` posjećuje se zasebno preko `B` i preko `A`. Završni `false` potvrđuje da `A` više nije na aktivnom putu.
Povezane lekcije
- Java · Lekcija 59 · Napredno · Verzija: 2