Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Členství v množině `Set` a detekce cyklů

Ověřuj přítomnost prvků v `Set`, přidávej je a odebírej. Návratová hodnota `add` odhalí typ na aktivní cestě a `finally` odebere jeho záznam při ukončení volání.

Verze: Java SE 21

Syntaxe

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í členství na rovnosti prvků podle Objects.equals, nikoli na jejich pozici. contains(Object o) vrací true, pokud množina obsahuje rovný prvek, a množinu nemění. add(E e) vrátí true, když prvek vloží; u duplicity vrátí false a nic nezmění. remove(Object o) vrátí true, když odebere rovný prvek, a false, když žádný takový prvek není přítomen. Parametr Object znamená, že hledání ani odebírání nevyžaduje argument typu E; odebírá se podle hodnoty, ne podle indexu.

Vkládání a odebírání jsou volitelné operace: množina vytvořená pomocí Set.of je odmítne výjimkou UnsupportedOperationException. Podle implementace může add odmítnout null, nekompatibilní typ nebo nepovolenou vlastnost prvku výjimkou NullPointerException, ClassCastException, respektive IllegalArgumentException. Při hledání nebo odebírání nepovoleného null nebo hodnoty nekompatibilního typu může implementace vrátit false nebo vyvolat příslušnou výjimku. Použij měnitelný HashSet s klíči, jejichž equals a hashCode zůstávají po dobu uložení stabilní.

Při rekurzivním procházení závislostí mezi typy udržuj v množině jen typy z aktuální cesty. !active.add(type) odhalí cyklus bez předchozího volání contains. Ve větvi, která detekuje cyklus, záznam neodebírej: patří dřívějšímu volání. Do try vstup až po úspěšném vložení a záznam odeber ve finally, které se provede při běžném opuštění bloku, při return i při šíření výjimky. Množina neuchovává pořadí zásobníku ani všechny dříve navštívené typy; jiná větev může stejný typ navštívit znovu.

Pří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ýsledek

visit: A
visit: B
cycle: A
visit: C
visit: C
A active after traversal: false

`B` odhalí návrat k dosud aktivnímu `A`. Typ `C` se navštíví zvlášť přes `B` a přes `A`. Závěrečné `false` potvrzuje, že `A` už není na aktivní cestě.

Související lekce

  • Java · Lekce 59 · Pokročilá · Verze: 2

Zdroje