Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Appartenenza a un `Set` e rilevamento dei cicli

Verifica, aggiungi e rimuovi elementi in un `Set`. Il risultato di `add` segnala un tipo già sul percorso attivo, mentre `finally` rimuove l’elemento quando la chiamata termina.

Versione: Java SE 21

Sintassi

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

In java.util.Set<E>, l’appartenenza si basa sull’uguaglianza definita da Objects.equals, non sulla posizione. contains(Object o) restituisce true se è presente un elemento uguale, senza modificare l’insieme. add(E e) restituisce true quando inserisce l’elemento; se è un duplicato, restituisce false e non cambia nulla. remove(Object o) restituisce true se rimuove un elemento uguale e false se non ce n’è alcuno. Il parametro Object indica che la ricerca e la rimozione non richiedono un argomento di tipo E; la rimozione avviene per valore, non per indice.

L’inserimento e la rimozione sono operazioni facoltative: un insieme creato con Set.of le rifiuta con UnsupportedOperationException. A seconda dell’implementazione, add può rifiutare null, un tipo incompatibile o una proprietà non ammessa dell’elemento con NullPointerException, ClassCastException o IllegalArgumentException, rispettivamente. Se si cerca o si tenta di rimuovere un null non consentito o un valore di tipo incompatibile, l’implementazione può restituire false o lanciare l’eccezione corrispondente. Usa un HashSet modificabile con chiavi i cui equals e hashCode restino stabili finché sono nell’insieme.

Quando percorri ricorsivamente le dipendenze tra tipi, conserva nell’insieme soltanto quelli del percorso corrente. !active.add(type) rileva un ciclo senza chiamare prima contains. Non rimuovere l’elemento nel ramo che rileva il ciclo: appartiene a una chiamata precedente. Entra in try solo dopo un inserimento riuscito e rimuovi l’elemento in finally, che viene eseguito all’uscita normale, con return e quando si propaga un’eccezione. L’insieme non conserva né l’ordine dello stack né tutti i tipi già visitati: un altro ramo può visitare nuovamente lo stesso tipo.

Esempi

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

Risultato

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

`B` rileva il ritorno ad `A`, ancora attivo. `C` viene visitato separatamente passando per `B` e per `A`. Il `false` finale conferma che `A` non è più sul percorso attivo.

Lezioni correlate

  • Java · Lezione 59 · Avanzato · Versione: 2

Fonti