CKTIS / Java
Pertenencia a un `Set` y detección de ciclos
Comprueba, añade y elimina elementos de un `Set`. El resultado de `add` detecta un tipo que ya está en la ruta activa, y `finally` elimina su entrada al salir de la llamada.
Versión: Java SE 21
Sintaxis
Java SE 21 — instance methods of java.util.Set<E>:
boolean add(E e);
boolean contains(Object o);
boolean remove(Object o);En java.util.Set<E>, la pertenencia depende de la igualdad definida por Objects.equals, no de la posición. contains(Object o) devuelve true si hay un elemento igual, sin modificar el conjunto. add(E e) devuelve true al insertar el elemento; si está duplicado, devuelve false y no cambia nada. remove(Object o) devuelve true si elimina un elemento igual y false si no hay ninguno. El parámetro Object significa que la consulta y la eliminación no requieren un argumento de tipo E; se elimina por valor, no por índice.
La inserción y la eliminación son operaciones opcionales: un conjunto creado con Set.of las rechaza con UnsupportedOperationException. Según la implementación, add puede rechazar null, un tipo incompatible o una propiedad no admitida del elemento con NullPointerException, ClassCastException o IllegalArgumentException, respectivamente. Al consultar o eliminar un null no permitido o un valor de tipo incompatible, la implementación puede devolver false o lanzar la excepción correspondiente. Usa un HashSet modificable con claves cuyos equals y hashCode se mantengan estables mientras estén en el conjunto.
Al recorrer recursivamente dependencias entre tipos, conserva en el conjunto solo los tipos de la ruta actual. !active.add(type) detecta un ciclo sin llamar antes a contains. No elimines la entrada en la rama que detecta el ciclo: pertenece a una llamada anterior. Entra en try solo tras insertar el elemento y elimina la entrada en finally, que se ejecuta al salir normalmente, al hacer return y al propagarse una excepción. El conjunto no guarda el orden de la pila ni todos los tipos ya visitados; otra rama puede volver a visitar el mismo tipo.
Ejemplos
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` detecta el regreso a `A`, que sigue activo. `C` se visita por separado a través de `B` y de `A`. El `false` final confirma que `A` ya no está en la ruta activa.
Lecciones relacionadas
- Java · Lección 59 · Avanzado · Versión: 2