CKTIS / Java
Pertença a um `Set` e deteção de ciclos
Verifica, adiciona e remove elementos de um `Set`. O resultado de `add` deteta um tipo que já está no caminho ativo, e `finally` remove a entrada quando a chamada termina.
Versão: Java SE 21
Sintaxe
Java SE 21 — instance methods of java.util.Set<E>:
boolean add(E e);
boolean contains(Object o);
boolean remove(Object o);Em java.util.Set<E>, a pertença depende da igualdade definida por Objects.equals, não da posição. contains(Object o) devolve true se existir um elemento igual, sem alterar o conjunto. add(E e) devolve true quando insere o elemento; se for um duplicado, devolve false e não altera o conjunto. remove(Object o) devolve true se remover um elemento igual e false se não existir nenhum. O parâmetro Object significa que a consulta e a remoção não exigem um argumento do tipo E; a remoção é feita por valor, não por índice.
A inserção e a remoção são operações opcionais: um conjunto criado com Set.of rejeita-as com UnsupportedOperationException. Consoante a implementação, add pode rejeitar null, um tipo incompatível ou uma propriedade inválida do elemento com NullPointerException, ClassCastException ou IllegalArgumentException, respetivamente. Ao consultar ou tentar remover um null não permitido ou um valor de tipo incompatível, a implementação pode devolver false ou lançar a exceção correspondente. Usa um HashSet modificável com chaves cujos equals e hashCode permaneçam estáveis enquanto estiverem no conjunto.
Ao percorrer recursivamente dependências entre tipos, mantém no conjunto apenas os tipos do caminho atual. !active.add(type) deteta um ciclo sem uma chamada prévia a contains. Não removas a entrada no ramo que deteta o ciclo: pertence a uma chamada anterior. Entra em try só depois de inserires o elemento e remove a entrada em finally, que é executado à saída normal, num return e quando se propaga uma exceção. O conjunto não guarda a ordem da pilha nem todos os tipos já visitados; outro ramo pode voltar a visitar o mesmo tipo.
Exemplos
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);
}
}
}Resultado
visit: A visit: B cycle: A visit: C visit: C A active after traversal: false
`B` deteta o regresso a `A`, que ainda está ativo. `C` é visitado separadamente através de `B` e de `A`. O `false` final confirma que `A` já não está no caminho ativo.
Lições relacionadas
- Java · Lição 59 · Avançado · Versão: 2