Wie mache ich meinen String-Vergleich case insensitive?

Question

Ich habe ein Java-Programm zwei Strings vergleichen:

String s1 = "Hello"; 
String s2 = "hello"; 

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

Es zeigt "Willkommen". Ich verstehe, dass es Groß- und Kleinschreibung ist. Aber mein Problem ist, dass ich zwei Strings ohne Berücksichtigung der Groß-/Kleinschreibung vergleichen möchte. I.e. Ich erwarte, dass die Ausgabe hai ist.

Answer 1

Verwendung String.equalsIgnoreCase()

Verwenden Sie die Java-API-Referenz Antworten wie diese zu finden.

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/

Answer 2

• Die beste s1.equalsIgnoreCase(s2) Verwendung würde: (siehe javadoc)
• Sie auch, sie beide zu Groß-/Kleinschreibung umwandeln und verwenden s1.equals(s2)

Answer 3

Verwenden Sie s1.equalsIgnoreCase (s2)
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.Object)

Answer 4

können Sie verwenden equalsIgnoreCase

Answer 5

Mehr über String kann in String Class und String Tutorials

Answer 6

Sie haben die compareToIgnoreCase Methode des String Objekt zu verwenden, zu finden.

int compareValue = str1.compareToIgnoreCase(str2); 

if (compareValue == 0) es bedeutet str1str2 entspricht.

Answer 7

Beachten Sie, dass Sie möglicherweise auch vor dem Ausführen von .equals oder .equalsIgnoreCase eine Nullprüfung durchführen möchten.

Ein Null-String-Objekt kann keine equals-Methode aufrufen.

dh:

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

Answer 8

In der Standard-Java-API Sie haben:

String.CASE_INSENSITIVE_ORDER 

So brauchen Sie nicht einen Komparator neu zu schreiben, wenn Sie Strings mit sortierten Datenstrukturen verwenden waren.

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

Ist, was Sie für reine Gleichheitsprüfungen in Ihrem eigenen Code wollen.

Nur um weitere Informationen über alles bezüglich der Gleichheit von Strings in Java. Die hashCode() Funktion der Klasse java.lang.String „Groß- und Kleinschreibung“:

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

Wenn Sie also eine Hashtable/HashMap mit Strings als Schlüssel verwenden möchten, und haben Schlüssel wie „somekey“, " SOMEKEY "und" somekey "werden als gleich angesehen, dann müssen Sie die Zeichenfolge in eine andere Klasse umbrechen (Sie können String nicht erweitern, da es sich um eine letzte Klasse handelt).Zum Beispiel:

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

und es dann als solche verwendet werden:

HashMap<HashWrap, Object> map = new HashMap<HashWrap, Object>(); 

Answer 9

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<str1.length();i++,j++) 
    { 
     if(str1.charAt(i)!=str2.charAt(j)) 
     return false; 
    }`enter code here` 
} 
return true; 
} 

Answer 10

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

Jetzt wird es Ausgabe: hai

Answer 11

String.equalsIgnoreCase ist die praktischste Wahl für naive Fall- unempfindlicher Stringvergleich.

Es ist jedoch gut zu wissen, dass diese Methode weder vollständige Faltung noch Zerlegung durchführt, und kann daher keine falllose Übereinstimmung wie im Unicode-Standard angegeben durchführen. Tatsächlich bieten die JDK-APIs keinen Zugriff auf Informationen über Fallfaltungszeichendaten, daher wird dieser Job am besten an eine bewährte Drittanbieterbibliothek delegiert.

Diese Bibliothek ist ICU, und hier ist, wie man ein Dienstprogramm für die Groß- und Kleinschreibung String-Vergleich implementieren könnte:

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

Naive Vergleich mit String.equalsIgnoreCase oder String.equals auf Groß- oder Kleinbuchstaben Saiten wird selbst dieser einfache Test versagen.

(Zu beachten ist aber, dass der vorgegebene Fall Geschmack Falten getNFKCCasefoldInstance ist locale-unabhängig;. Für türkische Gegenden ein wenig mehr Arbeit UCharacter.foldCase Beteiligung erforderlich sein kann)

Answer 12

Um Nullsafe, können Sie

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

oder

org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence)