Overriding hashCode with overridden equals using equalsIgnoreCase to check equality

Question

I've currently got an overridden equals(Object) that looks like this:

@Override
public boolean equals(Object o) {
    if (o == this) return true;
    if (! (o instanceof Player)) return false;
    Player p = (Player) o;
    return getFirstName().equalsIgnoreCase(p.getFirstName()) && 
            getLastName().equalsIgnoreCase(p.getLastName());
}

My hashCode() currently looks like this:

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + getFirstName().toLowerCase().hashCode();
    result = 31 * result + getLastName().toLowerCase().hashCode();
    return result;
}

My question is regarding my overridden hashCode() method. I know that I need hashCode() to return the same value for two objects if they are considered equal by the equals(Object) method. My gut tells me there is some case where this hashCode() will violate the contract.

Is there an acceptable way to use the equalsIgnoreCase(String) method in an overridden equals(Object) method and generate a hashcode that doesn't violate the contract?

Answer 1

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + characterwiseCaseNormalize(getFirstName()).hashCode();
    result = 31 * result + characterwiseCaseNormalize(getLastName()).hashCode();
    return result;
}

private static String characterwiseCaseNormalize(String s) {
    StringBuilder sb = new StringBuilder(s);
    for(int i = 0; i < sb.length(); i++) {
        sb.setCharAt(i,Character.toLowerCase(Character.toUpperCase(sb.charAt(i))));
    }
    return sb.toString();
}

This hashCode will be consistent with an equals defined using equalsIgnoreCase. In principle, according to the contract of equalsIgnoreCase, this seems to rely on it being the case that

Character.toLowerCase(Character.toUpperCase(c1))==Character.toLowerCase(Character.toUpperCase(c2))

whenever

Character.toLowerCase(c1)==Character.toLowerCase(c2).  

I don't have proof that that is true, but the OpenJDK implementation of equalsIgnoreCase actually does it consistently with this method; it checks whether corresponding characters are equals, then whether their upper case versions are equals, then whether the lower case versions of the upper case versions are equal.