web-dev-qa-db-fra.com

Comment rendre ma comparaison de chaînes insensible à la casse?

J'ai créé un programme Java pour comparer deux chaînes:

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

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

Il affiche "bienvenue". Je comprends que c'est sensible à la casse. Mais mon problème est que je veux comparer deux chaînes sans tenir compte de la casse. C'est à dire. Je m'attends à ce que la sortie soit hai.

javastringcomparisoncase-insensitive
108
user268018
  • Le mieux serait d’utiliser s1.equalsIgnoreCase(s2): (voir javadoc )
  • Vous pouvez également les convertir en majuscules/minuscules et utiliser s1.equals(s2)
166
Michael Bavin

utiliser String.equalsIgnoreCase()

Utilisez la référence d'API Java pour trouver des réponses comme celles-ci.

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/

41
Thirler

String.equalsIgnoreCase est le choix le plus pratique pour la comparaison de chaînes naïve sans distinction de casse.

Cependant, il est bon de savoir que cette méthode ne fait ni le pliage de casse complet ni la décomposition et donc ne peut pas effectuer de correspondance sans cas comme spécifié dans la norme Unicode. En fait, les API JDK ne permettent pas d'accéder aux informations relatives aux données de caractères de pliage de cas, il est donc préférable de déléguer ce travail à une bibliothèque tierce testée et testée.

Cette bibliothèque est ICU , et voici comment on pourrait implémenter un utilitaire de comparaison de chaînes ne respectant pas la casse:

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

La comparaison naïve avec _String.equalsIgnoreCase_ ou _String.equals_ sur des chaînes de caractères majuscules ou minuscules échouera même ce test simple.

(Notez cependant que la variante de casse prédéfinie getNFKCCasefoldInstance est indépendante des paramètres régionaux; pour les paramètres régionaux turcs, un travail un peu plus complexe impliquant UCharacter.foldCase peut être nécessaire.)

22
glts

Vous devez utiliser la méthode compareToIgnoreCase de l'objet String.

int compareValue = str1.compareToIgnoreCase(str2);

if (compareValue == 0) cela signifie str1 est égal à str2.

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

Maintenant, il va sortir: hai

10
KNU

Dans l'API Java par défaut, vous avez:

String.CASE_INSENSITIVE_ORDER

Vous n'avez donc pas besoin de réécrire un comparateur si vous utilisiez des chaînes avec des structures de données triées.

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

Est-ce ce que vous voulez pour des contrôles d'égalité pure dans votre propre code.

Juste pour en savoir plus sur tout ce qui concerne l’égalité des chaînes en Java. La fonction hashCode () de la classe Java.lang.String "est sensible à la casse":

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

Donc, si vous voulez utiliser une table de hachage/table de hachage avec des chaînes comme clés et que des clés telles que "SomeKey", "SOMEKEY" et "somekey" soient considérées comme égales, vous devrez alors envelopper votre chaîne dans une autre classe (vous ne pouvez pas étendre la chaîne). String puisque c'est une classe finale). Par exemple :

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

et ensuite l'utiliser comme tel:

HashMap<HashWrap, Object> map = new HashMap<HashWrap, Object>();
4
ɭɘ ɖɵʊɒɼɖ 江戸

Notez que vous pouvez également effectuer des vérifications nulles avant d’effectuer vos .equals ou .equalsIgnoreCase.

Un objet null String ne peut pas appeler une méthode equals.

c'est à 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);
}
2
VeenarM

utilisez s1.equalsIgnoreCase (s2)
http://Java.Sun.com/j2se/1.4.2/docs/api/Java/lang/String.html#equalsIgnoreCase (Java.lang.Object)

1
Morfildur

Vous pouvez utiliser equalsIgnoreCase

1
codaddict

Vous trouverez plus d'informations sur les chaînes dans String Class et String Tutorials

1
Gopi

Pour être nullsafe, vous pouvez utiliser

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

ou

org.Apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence)
0
brandstaetter