Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Pripadnost množici `Set` in zaznavanje ciklov

Preverjaj pripadnost množici `Set` ter dodajaj in odstranjuj elemente. Rezultat `add` zazna tip, ki je že na aktivni poti, `finally` pa ob izhodu iz klica odstrani vnos.

Različica: 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);

V java.util.Set<E> pripadnost določa enakost po Objects.equals, ne položaj elementa. contains(Object o) vrne true, če je prisoten enak element, in množice ne spremeni. add(E e) vrne true, ko vstavi element; pri dvojniku vrne false in množice ne spremeni. remove(Object o) vrne true, ko odstrani enak element, in false, če takega elementa ni. Parameter Object pomeni, da iskanje in odstranjevanje ne zahtevata argumenta tipa E; odstranjevanje poteka po vrednosti, ne po indeksu.

Vstavljanje in odstranjevanje sta neobvezni operaciji: množica, ustvarjena z Set.of, ju zavrne z UnsupportedOperationException. Odvisno od implementacije lahko add zavrne null, nezdružljiv tip ali nedovoljeno lastnost elementa z NullPointerException, ClassCastException oziroma IllegalArgumentException. Pri iskanju ali odstranjevanju nedovoljenega null ali vrednosti nezdružljivega tipa lahko implementacija vrne false ali sproži ustrezno izjemo. Uporabi spremenljiv HashSet s ključi, katerih equals in hashCode ostaneta stabilna, dokler so v množici.

Pri rekurzivnem pregledovanju odvisnosti med tipi v množici hrani le tipe s trenutne poti. !active.add(type) zazna cikel brez predhodnega klica contains. V veji, ki zazna cikel, vnosa ne odstrani: pripada prejšnjemu klicu. V try vstopi šele po uspešnem vstavljanju in vnos odstrani v finally, ki se izvede ob običajnem izhodu, ob return in ob širjenju izjeme. Množica ne hrani vrstnega reda sklada niti vseh doslej obiskanih tipov; druga veja lahko isti tip obišče znova.

Primeri

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` zazna vrnitev k še vedno aktivnemu `A`. Tip `C` je obiskan ločeno prek `B` in prek `A`. Zadnji `false` potrdi, da `A` ni več na aktivni poti.

Povezane lekcije

  • Java · Lekcija 59 · Napredna · Različica: 2

Viri