База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Принадлежност към `Set` и откриване на цикли

Проверявай, добавяй и премахвай елементи в `Set`. Резултатът от `add` открива тип, който вече е в активния път, а `finally` премахва записа при излизане от извикването.

Версия: Java SE 21

Синтаксис

Java SE 21 — instance methods of java.util.Set<E>:
boolean add(E e);
boolean contains(Object o);
boolean remove(Object o);

В java.util.Set<E> принадлежността се определя от равенството според Objects.equals, а не от позицията. contains(Object o) връща true, ако има равен елемент, без да променя множеството. add(E e) връща true, когато добави елемента; при дубликат връща false и не променя множеството. remove(Object o) връща true, ако премахне равен елемент, и false, ако няма такъв. Параметърът Object означава, че проверката и премахването не изискват аргумент от тип E; премахването е по стойност, а не по индекс.

Добавянето и премахването са незадължителни операции: множество, създадено със Set.of, ги отказва с UnsupportedOperationException. Според реализацията add може да отхвърли null, несъвместим тип или недопустимо свойство на елемента съответно с NullPointerException, ClassCastException или IllegalArgumentException. При проверка или премахване на недопустим null или стойност от несъвместим тип реализацията може да върне false или да хвърли съответното изключение. Използвай изменяем HashSet с ключове, чиито equals и hashCode остават стабилни, докато са в множеството.

При рекурсивно обхождане на зависимости между типове пази в множеството само типовете от текущия път. !active.add(type) открива цикъл без предварително извикване на contains. Не премахвай записа в клона, който открива цикъла: той принадлежи на по-ранно извикване. Влез в try само след успешно добавяне и премахни записа във finally, който се изпълнява при нормално излизане, при return и при разпространяване на изключение. Множеството не пази нито реда на стека, нито всички посетени типове; друг клон може отново да посети същия тип.

Примери

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);
        }
    }
}

Резултат

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

`B` открива връщането към все още активния `A`. Типът `C` се посещава отделно през `B` и през `A`. Последното `false` потвърждава, че `A` вече не е в активния път.

Свързани уроци

  • Java · Урок 59 · Напреднало · Версия: 2

Източници