Come faccio a rendere insensibile la mia comparazione delle stringhe?

Ho creato un programma Java per confrontare due stringhe:

String s1 = "Hello"; String s2 = "hello"; if (s1.equals(s2)) { System.out.println("hai"); } else { System.out.println("welcome"); } 

Visualizza “benvenuto”. Capisco che sia case sensitive. Ma il mio problema è che voglio confrontare due stringhe senza distinzione tra maiuscole e minuscole. Vale a dire, mi aspetto che l’output sia hai .

  • La cosa migliore sarebbe usare s1.equalsIgnoreCase(s2) : (vedi javadoc )
  • Puoi anche convertirli entrambi in maiuscolo / minuscolo e usare s1.equals(s2)

usa String.equalsIgnoreCase()

Utilizzare il riferimento API Java per trovare risposte come queste.

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

http://java.sun.com/j2se/1.5.0/docs/api/

String.equalsIgnoreCase è la scelta più pratica per il confronto di stringa ingenuo senza distinzione tra maiuscole e minuscole.

Tuttavia, è bene essere consapevoli del fatto che questo metodo non esegue né la piegatura full case né la decomposizione e quindi non può eseguire la corrispondenza senza spazio come specificato nello standard Unicode. In effetti, le API JDK non forniscono accesso alle informazioni sui dati dei caratteri di piegatura dei casi, quindi questo lavoro è meglio delegato a una libreria di terze parti comprovata.

Quella libreria è ICU , ed ecco come si potrebbe implementare un’utilità per il confronto tra stringhe senza distinzione tra maiuscole e minuscole:

 import com.ibm.icu.text.Normalizer2; // ... public static boolean equalsIgnoreCase(CharSequence s, CharSequence t) { Normalizer2 normalizer = Normalizer2.getNFKCCasefoldInstance(); return normalizer.normalize(s).equals(normalizer.normalize(t)); } 
  String brook = "flu\u0308ßchen"; String BROOK = "FLÜSSCHEN"; assert equalsIgnoreCase(brook, BROOK); 

Confronto ingenuo con String.equalsIgnoreCase o String.equals su stringhe maiuscole o minuscole fallirà anche in questo semplice test.

(Si noti però che l’aroma di getNFKCCasefoldInstance case predefinito getNFKCCasefoldInstance è indipendente dalla locale, per i locali turchi potrebbe essere necessario un po ‘più di lavoro che coinvolge UCharacter.foldCase .)

Devi usare il metodo compareToIgnoreCase dell’object String .

 int compareValue = str1.compareToIgnoreCase(str2); 

if (compareValue == 0) significa che str1 uguale a str2 .

 import java.lang.String; //contains equalsIgnoreCase() /* * */ String s1 = "Hello"; String s2 = "hello"; if (s1.equalsIgnoreCase(s2)) { System.out.println("hai"); } else { System.out.println("welcome"); } 

Ora uscirà: hai

Nell’API Java predefinita hai:

 String.CASE_INSENSITIVE_ORDER 

Quindi non è necessario riscrivere un comparatore se si dovessero utilizzare stringhe con strutture dati ordinate.

 String s = "some text here"; s.equalsIgnoreCase("Some text here"); 

È quello che vuoi per i veri controlli di uguaglianza nel tuo codice.

Solo per ulteriori informazioni su tutto ciò che riguarda l’uguaglianza delle stringhe in Java. La funzione hashCode () della class java.lang.String “distingue tra maiuscole e minuscole”:

 public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char val[] = value; for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; } return h; } 

Quindi se vuoi usare una Hashtable / HashMap con stringhe come chiavi e avere chiavi come "SomeKey", "SOMEKEY" e "somekey" essere viste come uguali, allora dovrai avvolgere la tua stringa in un'altra class (non puoi estendere Stringa poiché è una class finale). Per esempio :

 private static class HashWrap { private final String value; private final int hash; public String get() { return value; } private HashWrap(String value) { this.value = value; String lc = value.toLowerCase(); this.hash = lc.hashCode(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o instanceof HashWrap) { HashWrap that = (HashWrap) o; return value.equalsIgnoreCase(that.value); } else { return false; } } @Override public int hashCode() { return this.hash; } } 

e quindi usarlo come tale:

 HashMap map = new HashMap(); 

Nota che potresti voler fare controlli nulli anche prima di fare il tuo .equals o .equalsIgnoreCase.

Un object String null non può chiamare un metodo uguale.

vale a dire:

 public boolean areStringsSame(String str1, String str2) { if (str1 == null && str2 == null) return true; if (str1 == null || str2 == null) return false; return str1.equalsIgnoreCase(str2); } 

Puoi usare equalsIgnoreCase

Ulteriori informazioni sulla stringa sono disponibili nelle esercitazioni String Class e String

Per essere nullo, puoi usare

 org.apache.commons.lang.StringUtils.equalsIgnoreCase(String, String) 

o

 org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence) 
 public boolean newEquals(String str1, String str2) { int len = str1.length(); int len1 = str2.length(); if(len==len1) { for(int i=0,j=0;i