Comparar objetos usando contains() en java

Método contains() en Java

Cuando trabajamos con colecciones en Java, es frecuente necesitar verificar si un elemento ya existe antes de agregarlo o procesarlo. Para ello, la interfaz Collection proporciona el método contains().

Uso básico

Con tipos simples como String, el comportamiento es intuitivo:

ArrayList<String> nombres = new ArrayList<>();

nombres.add("Juan");
nombres.add("Ana");

System.out.println(nombres.contains("Ana"));

Salida:

true

El método devuelve true si encuentra un elemento equivalente dentro de la colección.

Uso con objetos personalizados

Cuando la colección almacena objetos definidos por nosotros, contains() utiliza el método equals() para determinar si dos objetos son iguales.

Supongamos la siguiente clase:

public class Animal {

    private int id;
    private String nombre;

    public Animal(int id, String nombre) {
        this.id = id;
        this.nombre = nombre;
    }
}

Si intentamos buscar un objeto con el mismo ID pero creado en otra instancia:

ArrayList<Animal> animales = new ArrayList<>();

animales.add(new Animal(1, "Firulais"));

Animal buscado = new Animal(1, "Otro Nombre");

System.out.println(animales.contains(buscado));

El resultado será:

false

Esto ocurre porque la implementación por defecto de equals() compara referencias de memoria y no el contenido de los objetos.

Sobrescribiendo equals()

Para que dos animales sean considerados iguales cuando comparten el mismo ID, debemos sobrescribir equals():

@Override
public boolean equals(Object obj) {

    if (this == obj)
        return true;

    if (!(obj instanceof Animal))
        return false;

    Animal otro = (Animal) obj;

    return this.id == otro.id;
}

Ahora el mismo ejemplo devolverá:

true

La importancia de hashCode()

Siempre que se sobrescribe equals(), también debe sobrescribirse hashCode().

@Override
public int hashCode() {
    return Integer.hashCode(id);
}

Esto es especialmente importante cuando se utilizan estructuras basadas en tablas hash, como:

• HashSet
• LinkedHashSet
• HashMap

La regla fundamental es:

Si dos objetos son iguales según equals(), deben devolver el mismo valor de hashCode().

contains() en un Set

Con un conjunto (Set), la búsqueda suele ser más eficiente:

Set<Animal> animales = new LinkedHashSet<>();

animales.add(new Animal(1, "Firulais"));

boolean existe = animales.contains(
    new Animal(1, "Otro Nombre")
);

Siempre que equals() y hashCode() estén correctamente implementados, el resultado será el esperado.

Evitando elementos duplicados

Una ventaja adicional de los conjuntos es que no permiten duplicados.

Animal nuevo = new Animal(1, "Toby");

if (!animales.add(nuevo)) {
    System.out.println("ID duplicado");
}

El método add() devuelve false cuando el elemento ya existe según los criterios definidos en equals().

Conclusión

El método contains() es una herramienta sencilla pero fundamental para verificar la existencia de elementos en una colección. Con tipos personalizados, su comportamiento depende directamente de una correcta implementación de equals() y, en estructuras basadas en hash, también de hashCode().

Comprender esta relación es clave para evitar duplicados, realizar búsquedas confiables y aprovechar correctamente las colecciones del framework de Java.