Am I using HashSet.contains() wrong?

Well, you have an expectation which is wrong, but it's more about arrays than about HashSet. Arrays in Java don't implement equals and hashCode in the way it looks like you're expecting them to. They effectively exhibit reference equality behaviour. For example:

int[] array1 = { 1 };
int[] array2 = { 1 };
System.out.println(array1.equals(array1)); // true - same reference
System.out.println(array1.equals(array2)); // false - different reference

Rather than using an int[] for coordinates, I'd suggest creating a Coordinate class with x and y fields. If that Coordinate class then overrides equals and hashCode appropriately, then using HashSet will work. (Although I'd advise creating the object you're looking for outside the loop rather than in each iteration.)

Whether multiple objects will match when they are identical depends on how equals() and hashCode() are implemented. For example for class A every object is the same since it has only one final field set to a constant.

public static class A {
    final int a=2;
}

But the HashSet see containing one as containing the other:

 A a1 = new A();
 HashSet<A> hsA = new HashSet<>();
 hsA.add(a1);
 A a2 = new A();
 System.out.println("hsA.contains(a2) = " + hsA.contains(a2));

Class B is the same but overrides hashCode() and equals():

public static class B {

    final int a = 2;

    @Override
    public int hashCode() {
        int hash = 5;
        hash = 17 * hash + this.a;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final B other = (B) obj;
        if (this.a != other.a) {
            return false;
        }
        return true;
    }

}

Running almost the same code:

    B b1 = new B();
    HashSet<B> hsB = new HashSet<>();
    hsB.add(b1);
    B b2 = new B();
    System.out.println("hsB.contains(b2) = " + hsB.contains(b2));

produces a different value. The output is :

hsA.contains(a2) = false
hsB.contains(b2) = true

Most IDE's have an option to generate hashCode() and equals() so that whether objects match can depend on exactly the fields you specify.

If the hash code method is based on the name field, and you then change it after adding the object, then the second contains check will use the new hash value, and won't find the object you were looking for. This is because HashSets first search by hash code, so they won't bother calling equals if that search fails.

The only way this would work is if you hadn't overridden equals (and so the default reference equality was used) and you got lucky and the hash codes of the two objects were equal. But this is a really unlikely scenario, and you shouldn't rely on it.

In general, you should never update an object after you have added it to a HashSet if that change will also change its hashcode.