¿Cómo evalúa un objeto el método contiene () de ArrayList?

Digamos que creo un objeto y lo agrego a mi ArrayList. Si luego creo otro objeto con exactamente la misma entrada del constructor, ¿evaluará el contains()método que los dos objetos sean iguales? Suponga que el constructor no hace nada divertido con la entrada, y las variables almacenadas en ambos objetos son idénticas.

ArrayList<Thing> basket = new ArrayList<Thing>();  
Thing thing = new Thing(100);  
basket.add(thing);  
Thing another = new Thing(100);  
basket.contains(another); // true or false?

class Thing {  
    public int value;  

    public Thing (int x) {
        value = x;
    }

    equals (Thing x) {
        if (x.value == value) return true;
        return false;
    }
}

¿Es así como classdebería implementarse para tener contains()retorno true?

Array implementsLista la interfaz de la lista.

Si observa el Javadoc para verList el containsmétodo, verá que utiliza el equals()método para evaluar si dos objetos son iguales.

Creo que las implementaciones correctas deberían ser

public class Thing
{
    public int value;  

    public Thing (int x)
    {
        this.value = x;
    }

    @Override
    public boolean equals(Object object)
    {
        boolean sameSame = false;

        if (object != null && object instanceof Thing)
        {
            sameSame = this.value == ((Thing) object).value;
        }

        return sameSame;
    }
}

ArrayList utiliza el método de igualdad implementado en la clase (la clase Thing de su caso) para hacer la comparación de igualdad.

En general, también debe anular hashCode() cada vez que anula equals(), incluso si solo es para aumentar el rendimiento. HashCode()decide en qué 'cubo' se ordena su objeto al hacer una comparación, por lo que dos objetos que se equal()evalúen como verdaderos deberían devolver lo mismo hashCode value(). No puedo recordar el comportamiento predeterminado de hashCode()(si devuelve 0, entonces su código debería funcionar pero lentamente, pero si devuelve la dirección, entonces su código fallará). Sin hashCode()embargo , recuerdo muchas veces cuando mi código falló porque olvidé anularlo . :)

Utiliza el método igual en los objetos. Entonces, a menos que Cosa anule la igualdad y use las variables almacenadas en los objetos para comparación, no devolverá verdadero en el contains()método.

class Thing {  
    public int value;  

    public Thing (int x) {
        value = x;
    }

    equals (Thing x) {
        if (x.value == value) return true;
        return false;
    }
}

Debes escribir:

class Thing {  
    public int value;  

    public Thing (int x) {
        value = x;
    }

    public boolean equals (Object o) {
    Thing x = (Thing) o;
        if (x.value == value) return true;
        return false;
    }
}

Ahora funciona ;)

Solo quería señalar que la siguiente implementación es incorrecta cuando valueno es un tipo primitivo:

public class Thing
{
    public Object value;  

    public Thing (Object x)
    {
        this.value = x;
    }

    @Override
    public boolean equals(Object object)
    {
        boolean sameSame = false;

        if (object != null && object instanceof Thing)
        {
            sameSame = this.value == ((Thing) object).value;
        }

        return sameSame;
    }
}

En ese caso, propongo lo siguiente:

public class Thing {
    public Object value;  

    public Thing (Object x) {
        value = x;
    }

    @Override
    public boolean equals(Object object) {

        if (object != null && object instanceof Thing) {
            Thing thing = (Thing) object;
            if (value == null) {
                return (thing.value == null);
            }
            else {
                return value.equals(thing.value);
            }
        }

        return false;
    }
}

Otros carteles han abordado la pregunta sobre cómo funciona contiene ().

Un aspecto igualmente importante de su pregunta es cómo implementar correctamente equals (). Y la respuesta a esto depende realmente de lo que constituye la igualdad de objetos para esta clase en particular. En el ejemplo que proporcionó, si tiene dos objetos diferentes que tienen x = 5, ¿son iguales? Realmente depende de lo que intentes hacer.

Si solo está interesado en la igualdad de objetos, entonces el valor predeterminado implementación de .equals () (la provista por Object) usa solo identidad (es decir, esto == otro). Si eso es lo que desea, simplemente no implemente equals () en su clase (deje que herede de Object). El código que escribió, si bien es correcto si busca identidad, nunca aparecerá en una clase real b / c, no proporciona ningún beneficio sobre el uso de la implementación predeterminada Object.equals ().

Si recién está comenzando con estas cosas, le recomiendo encarecidamente el libro Effective Java de Joshua Bloch. Es una gran lectura, y cubre este tipo de cosas (además de cómo implementar correctamente equals () cuando intentas hacer más que comparaciones basadas en identidad)

Atajo de JavaDoc :

boolean contiene (objeto o)

Devuelve verdadero si esta lista contiene el elemento especificado. Más formalmente, devuelve verdadero si y solo si esta lista contiene al menos un elemento e tal que (o == null? E == null: o.equals (e))