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 souhaite comparer deux chaînes sans respecter la casse. Ie je m'attends à ce que la sortie soit hai.

• Le mieux serait d'utiliser s1.equalsIgnoreCase(s2): (voir javadoc )
• Vous pouvez également les convertir en majuscules / minuscules et utiliser s1.equals(s2)

Utilisation String.equalsIgnoreCase() .

Utilisez la référence de l'API Java pour trouver des réponses comme celles-ci:

https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

https://docs.oracle.com/javase/1.5.0/docs/api/

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

Cependant, il est bon de savoir que cette méthode ne fait ni pliage ni décomposition complet de la casse et ne peut donc pas effectuer de correspondance sans casse comme spécifié dans la norme Unicode.En fait, les API JDK ne fournissent pas d'accès aux informations sur les 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 éprouvée.

Cette bibliothèque est ICU , et voici comment implémenter un utilitaire pour la comparaison de chaînes insensible à 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);

Comparaison naïve avec String.equalsIgnoreCase, ouString.equals sur des chaînes majuscules ou minuscules échouera même ce test simple.

(Notez cependant que la saveur prédéfinie de pliage de cas getNFKCCasefoldInstanceest indépendante des paramètres régionaux; pour les paramètres régionaux turcs, un peu plus de travail UCharacter.foldCasepeut être nécessaire.)

Vous devez utiliser la compareToIgnoreCaseméthode de l' Stringobjet.

int compareValue = str1.compareToIgnoreCase(str2);

if (compareValue == 0)cela signifie str1égal 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");
}

Maintenant, il affichera: hai

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 deviez utiliser des chaînes avec des structures de données triées.

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

C'est ce que vous voulez pour des vérifications d'égalité pure dans votre propre code.

Juste pour plus d'informations 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 un Hashtable / HashMap 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 String puisqu'il s'agit d'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;
    }
}

puis utilisez-le comme tel:

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

Notez que vous souhaiterez peut-être effectuer des vérifications nulles sur eux également avant de faire vos .equals ou .equalsIgnoreCase.

Un objet String nul 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);
}

Utilisation s1.equalsIgnoreCase(s2) : https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String) .

Vous pouvez utiliser equalsIgnoreCase

Vous trouverez plus d'informations sur la chaîne dans les didacticiels sur les classes de chaînes et les chaînes

Pour être nullsafe, vous pouvez utiliser

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

ou

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