Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

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

Zdroje