Ignorer les majuscules et les minuscules en Java

Pour vérifier si deux chaînes Java sont égales sans tenir compte de la casse, appelez equalsIgnoreCase(). Utilisez toUpperCase() ou toLowerCase(), puis equals(), si vous avez besoin de chaînes normalisées pour d’autres traitements. Pour trier sans tenir compte de la casse, utilisez compareToIgnoreCase().

Un String Java est immuable : toUpperCase() et toLowerCase() renvoient donc un String contenant le texte converti sans modifier la valeur d’origine. Ces méthodes et equalsIgnoreCase() appliquent les règles de casse de Java, mais ne réalisent pas un repliement complet de la casse Unicode propre à chaque langue. Choisissez la méthode selon que vous avez besoin de tester l’égalité, d’obtenir des valeurs normalisées ou de comparer l’ordre.

Ignorer la casse avec la méthode toUpperCase() en Java

Convertissez les deux chaînes avec toUpperCase(Locale.ROOT), puis comparez les résultats à l’aide de equals(). Locale.ROOT rend la conversion indépendante des paramètres régionaux par défaut de la machine, ce qui est utile pour une normalisation destinée au traitement informatique, par exemple celle d’identifiants. Les exemples ASCII courants ne nécessitent pas que les paramètres régionaux par défaut soient l’anglais ou l’anglais des États-Unis.

import java.util.Locale;

public class UppercaseComparison {
    public static void main(String[] args) {
        String first = "icecream";
        String second = "IceCream";

        String normalizedFirst = first.toUpperCase(Locale.ROOT);
        String normalizedSecond = second.toUpperCase(Locale.ROOT);
        boolean equalIgnoringCase = normalizedFirst.equals(normalizedSecond);

        System.out.println(equalIgnoringCase);
    }
}

Cette approche compare les valeurs String renvoyées après conversion. Utilisez Locale.ROOT lorsque la conversion sert à comparer des données entre machines ; le traitement de texte adapté à une langue peut nécessiter une autre approche.

Ignorer la casse avec la méthode toLowerCase() en Java

La normalisation en minuscules suit le même principe : convertissez les deux chaînes avec toLowerCase(Locale.ROOT), puis comparez-les à l’aide de equals(). Le choix explicite des paramètres régionaux évite que le résultat dépende de ceux définis par défaut par l’utilisateur. Cette approche convient si les traitements suivants ont également besoin des valeurs normalisées en minuscules ; pour tester directement l’égalité, equalsIgnoreCase() est plus simple.

import java.util.Locale;

public class LowercaseComparison {
    public static void main(String[] args) {
        String first = "icecream";
        String second = "IceCream";

        String normalizedFirst = first.toLowerCase(Locale.ROOT);
        String normalizedSecond = second.toLowerCase(Locale.ROOT);
        boolean equalIgnoringCase = normalizedFirst.equals(normalizedSecond);

        System.out.println(equalIgnoringCase);
    }
}

Comme la conversion en majuscules, toLowerCase() renvoie un String contenant le texte converti sans modifier la valeur d’origine ; cette méthode ne remplace pas le repliement de la casse Unicode propre à une langue.

Ignorer la casse avec la méthode equalsIgnoreCase() en Java

Pour tester directement l’égalité, appelez equalsIgnoreCase() sur une chaîne et transmettez l’autre en argument. La méthode renvoie un booléen : true si les chaînes sont égales selon la comparaison sans distinction de casse de Java, et false dans le cas contraire. Par exemple, "icecream".equalsIgnoreCase("IceCream") renvoie true.

public class IgnoreCaseEquality {
    public static void main(String[] args) {
        String first = "icecream";
        String second = "IceCream";

        boolean equalIgnoringCase = first.equalsIgnoreCase(second);
        System.out.println(equalIgnoringCase);
    }
}

La comparaison n’est adaptée à aucune langue ni à aucun paramètre régional en particulier, et elle ne réalise pas un repliement complet de la casse Unicode. Si une application doit appliquer des règles de comparaison linguistiques, utilisez une API conçue à cette fin au lieu de supposer que cette méthode couvre les conventions textuelles de toutes les langues.

Ignorer la casse avec la méthode compareToIgnoreCase() en Java

Utilisez compareToIgnoreCase() lorsque vous avez besoin d’un ordre lexicographique sans distinction de casse, par exemple pour trier des chaînes. Un résultat égal à zéro signifie que les chaînes sont considérées comme égales sans tenir compte de la casse. Un résultat négatif indique que la première chaîne précède la seconde ; un résultat positif indique qu’elle la suit. La valeur entière exacte d’un résultat non nul n’est pas nécessairement égale à la différence entre les premiers caractères qui diffèrent.

public class IgnoreCaseOrdering {
    public static void main(String[] args) {
        String first = "apple";
        String second = "Banana";

        int comparison = first.compareToIgnoreCase(second);
        System.out.println(comparison < 0);
    }
}

L’exemple affiche un booléen indiquant le résultat de la relation d’ordre. Si vous avez seulement besoin de tester l’égalité, utilisez plutôt equalsIgnoreCase().