hashCode Override con eguali ignorate utilizzando equalsIgnoreCase per verificare l'uguaglianza

Question

ho attualmente ottenuto un sovrascritto equals(Object) che assomiglia a questo:

@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()); 
} 

mio hashCode() attualmente si presenta così:

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

La mia domanda è riguardo il mio metodo hashCode() sovrascritto. So che ho bisogno di hashCode() per restituire lo stesso valore per due oggetti se sono considerati uguali dal metodo equals (Object). Il mio istinto mi dice che c'è del caso in cui questo hashCode() viola il contratto.

Esiste un modo accettabile di utilizzare il metodo equalsIgnoreCase (String) in un metodo equals (Object) sovrascritto e generare un hashcode che non violi il contratto?

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(); 
} 

Questo hashCode sarà coerente con un equals definito utilizzando equalsIgnoreCase.In linea di principio, in base al contratto di equalsIgnoreCase, questo sembra fare affidamento su di esso è il caso che

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

ogni volta

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

Non ho la prova che questo è vero, ma la realtà OpenJDK implementation of equalsIgnoreCase lo fa in modo coerente con questo metodo; controlla se i caratteri corrispondenti sono uguali, quindi se le loro versioni maiuscole sono uguali, allora se le versioni minuscole delle versioni maiuscole sono uguali.

Answer 2

Hai ragione. Possiamo scorrere tutte le stringhe di un carattere e trovare coppie s1,s2 che s1.equalsIgnoreCase(s2) && !s1.toLowerCase().equals(s2.toLowerCase()). Ci sono alcune coppie. Per esempio

s1=0049 'LATIN CAPITAL LETTER I' 
s2=0131 'LATIN SMALL LETTER DOTLESS I' 

s1.lowercase = 0069 'LATIN SMALL LETTER I' 
s2.lowercase = 0131 itself 

Dipende anche locale: per S1, uso turco e azero U + 0131 per la minuscola (vedi http://www.fileformat.info/info/unicode/char/0049/index.htm)

Answer 3

Hai ragione di essere preoccupati. Read the contract for equalsIgnoreCase.

due caratteri c1 e c2 sono considerati lo stesso caso ignorando se almeno una delle seguenti condizioni:

• I due caratteri sono uguali (rispetto dall'operatore ==)
• Applicazione il metodo Character.toUpperCase (char) a ciascun carattere produce lo stesso risultato
• Applicando il metodo Character.toLowerCase (char) a ciascun carattere produce lo stesso risultato

Quindi, se c'è un carattere che è uguale quando convertito in maiuscolo ma non viceversa, sarai nei guai.

Prendiamo l'esempio del carattere tedesco ß, che diventa two character sequence SS quando convertito in maiuscolo. Ciò significa che la stringa "ß" e "SS" sono "equalsIgnoreCase" ma non avrà la stessa rappresentazione quando convertita in minuscolo!

Quindi il tuo approccio qui è rotto. Sfortunatamente, non sono sicuro che sarai in grado di progettare un hashCode che esprima adeguatamente le tue necessità qui.

Answer 4

In termini di scrittura di un hashCode() coerente con equals(), si dovrebbe usare sia Character basata su caso-mapping in entrambi, o String basata su caso-mapping in entrambi. Nella mia altra risposta ho mostrato come scrivere un hashCode() usando il case-mapping basato su Character; ma c'è un'altra soluzione, che è quella di cambiare equals() invece di utilizzare il case-mapping basato su String. (Si noti che String.equalsIgnoreCase() utilizza Character basata su caso-mapping.)

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