使用Java ArrayList评估包含字符串的对象包含（）

Question

I would like to do a deeper String check of Objects to be able to do the following:

List<MyObj> myList = new ArrayList<MyObj>() {{
    add(new MyObj("hello"));
    add(new MyObj("world"));
}};

System.out.println(myList.contains("hello")); // true
System.out.println(myList.contains("foo")); // false
System.out.println(myList.contains("world")); // true

But getting false on each one with the following full code

/* Name of the class has to be "Main" only if the class is public. */
class Ideone {
    public static class MyObj {
        private String str;
        private int hashCode;

        public MyObj(String str) {
            this.str = str;
        }

        public @Override boolean equals(Object obj) {
            System.out.println("MyObj.equals(Object)");
            if (obj == this) {
                return true;
            }

            if (obj instanceof String) {
                String strObj = (String) obj;
                return strObj.equals(str);
            }

            return false;
        }

        public @Override int hashCode() {
            if (hashCode == 0) {
                hashCode = 7;
                for (int i = 0; i < str.length(); ++i) {
                    hashCode = hashCode * 31 + str.charAt(i);
                }
            }

            return hashCode;
        }
    }

    public static final MyObj obj1 = new MyObj("hello");
    public static final MyObj obj2 = new MyObj("world");
    public static void main (String[] args) throws java.lang.Exception {
        List<MyObj> myList = new ArrayList<MyObj>() {{
            add(obj1);
            add(obj2);
        }};

        System.out.println(myList.contains("hello"));
        System.out.println(myList.contains("foo"));
        System.out.println(myList.contains("world"));
    }
}

If I'm right the List Object should use equals() and hashCode() to evaluate containing Objects. So I @Override them and check their Strings additionally. But it never gets into equals() as there's no output MyObj.equals(Object) .

Answer 1

java.util.ArrayList#indexOf is used internally in ArrayList for contains() .

There is a check,

o.equals(elementData[i])

So there is comparison of string with your object, so String.equals() is invoked for check of equality.

Answer 2

You are not fulfilling the equals contract at all:

The equals method implements an equivalence relation on non-null object references:

• It is reflexive: for any non-null reference value x, x.equals(x) should return true. Yours is not reflexive .
• It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true. Yours is not symmetric.
• It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true. Yours is not transitive
• It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

So without respecting the contract for the method you can't expect intended behavior.

Just for example, what guarantees you that equals is going to be called on the object contained in the ArrayList and not in the other way, eg "hello".equals(new MyObj("hello")) . You have no guarantees about it but since equals is normally supposed to be symmetric than you shouldn't mind.

Answer 3

As pointed out by others, the problem is that your equals method is never called. When you invoke myList.contains("hello") , ArrayList checks whether "hello".equals(<MyObj>) , not the other way around.

Instead, I recommend implementing your equals method properly , so that two MyObject instances with equal value are considered equal, and then create a helper method like this:

public boolean myContains(List<MyObj> list, String value) {
    return list.contains(new MyObj(value));
}

Answer 4

List<MyObj> myList = new ArrayList<MyObj>()

is a list of MyObj , so you need to use MyObj while checking myList.contains :

System.out.println(myList.contains(new MyObj("hello")));
System.out.println(myList.contains(new MyObj("foo")));
System.out.println(myList.contains(new MyObj("world")));

Answer 5

You're asking the List to compare a String to a MyObj ... They are never going to be "equal". Try a map instead:

Map<String, MyObj> map = new HashMap<String, MyObj>() {{
    put("hello", new MyObj("hello"));
    put("world", new MyObj("world"));
}};

Then you can use:

if (map.containsKey("hello"))

and to get the corresponding object:

MyObj o = map.get("hello"); // get() returns null if key not found

Answer 6

It is not equals of your object called when contains executes but the one from String class. And String implementation checks with instanceof whether the class is a String to perform String-like operations to determine the answer. If object is not a String it will return false;