Java Language Comparaison de chaînes


Exemple

Afin de comparer les chaînes pour l'égalité, vous devez utiliser les méthodes equals ou equalsIgnoreCase l'objet String.

Par exemple, l'extrait suivant déterminera si les deux instances de String sont égales sur tous les caractères:

String firstString = "Test123";
String secondString = "Test" + 123;

if (firstString.equals(secondString)) {
   // Both Strings have the same content.
}

Démo en direct

Cet exemple les comparera, indépendamment de leur cas:

String firstString = "Test123";
String secondString = "TEST123";

if (firstString.equalsIgnoreCase(secondString)) {
    // Both Strings are equal, ignoring the case of the individual characters.
}

Démo en direct

Notez que equalsIgnoreCase ne vous permet pas de spécifier une Locale . Par exemple, si vous comparez les deux mots "Taki" et "TAKI" en anglais, ils sont égaux; Cependant, ils sont différents en turc (en turc, le minuscule I est ı ). Pour les cas comme celui - ci, les deux chaînes de conversion en minuscules (ou majuscules) avec des Locale , puis en comparant avec equals est la solution.

String firstString = "Taki";
String secondString = "TAKI";

System.out.println(firstString.equalsIgnoreCase(secondString)); //prints true

Locale locale = Locale.forLanguageTag("tr-TR");

System.out.println(firstString.toLowerCase(locale).equals(
                   secondString.toLowerCase(locale))); //prints false

Démo en direct


N'utilisez pas l'opérateur == pour comparer des chaînes

Sauf si vous pouvez garantir que toutes les chaînes ont été internées (voir ci-dessous), vous ne devez pas utiliser les opérateurs == ou != Pour comparer des chaînes. Ces opérateurs testent en fait des références, et comme plusieurs objets String peuvent représenter la même chaîne, cela risque de donner une mauvaise réponse.

Utilisez String.equals(Object) la String.equals(Object) , qui comparera les objets String en fonction de leurs valeurs. Pour une explication détaillée, veuillez vous référer à Pitfall: utiliser == pour comparer des chaînes .


Comparaison de chaînes dans une déclaration de commutateur

Java SE 7

À partir de Java 1.7, il est possible de comparer une variable String à des littéraux dans une instruction switch . Assurez-vous que la chaîne n'est pas nulle, sinon elle lancera toujours une NullPointerException . Les valeurs sont comparées à l'aide de String.equals , c'est-à-dire, sensibles à la casse.

String stringToSwitch = "A";

switch (stringToSwitch) {
    case "a":
        System.out.println("a");
        break;
    case "A":
        System.out.println("A"); //the code goes here
        break;
    case "B":
        System.out.println("B");
        break;
    default:
        break;
}

Démo en direct

Comparaison de chaînes avec des valeurs constantes

Lorsque vous comparez une String à une valeur constante, vous pouvez placer la valeur constante sur le côté gauche des valeurs equals pour vous assurer de ne pas obtenir d'exception NullPointerException si l'autre chaîne est null .

"baz".equals(foo)

Alors que foo.equals("baz") lancera une NullPointerException si foo est null , "baz".equals(foo) sera évalué à false .

Java SE 7

Une alternative plus lisible consiste à utiliser Objects.equals() , qui effectue une vérification null sur les deux paramètres: Objects.equals(foo, "baz") .

( Remarque: il est discutable de savoir s'il vaut mieux éviter les NullPointerExceptions en général, ou les laisser se produire, puis corriger la cause première; voir ici et ici . L'appel à la stratégie d'évitement n'est pas justifiable.)

Classement des chaînes

La classe String implémente Comparable<String> avec la méthode String.compareTo (comme décrit au début de cet exemple). Cela rend l'ordre naturel des objets String ordre sensible à la casse. La classe String fournit une constante Comparator<String> appelée CASE_INSENSITIVE_ORDER adaptée au tri non sensible à la casse.

Comparaison avec des chaînes internes

La spécification de langage Java ( JLS 3.10.6 ) indique ce qui suit:

"De plus, un littéral de chaîne fait toujours référence à la même instance de la classe String . En effet, les littéraux de chaîne - ou plus généralement les chaînes d’expressions constantes - sont internés afin de partager des instances uniques, en utilisant la méthode String.intern . "

Cela signifie qu'il est prudent de comparer des références à deux littéraux de chaîne utilisant == . De plus, il en va de même pour les références aux objets String produits à l'aide de la méthode String.intern() .

Par exemple:

String strObj = new String("Hello!");
String str = "Hello!";

// The two string references point two strings that are equal
if (strObj.equals(str)) {
    System.out.println("The strings are equal");
}

// The two string references do not point to the same object
if (strObj != str) {
    System.out.println("The strings are not the same object");
}

// If we intern a string that is equal to a given literal, the result is
// a string that has the same reference as the literal.
String internedStr = strObj.intern();

if (internedStr == str) {
    System.out.println("The interned string and the literal are the same object");
}

Dans les coulisses, le mécanisme d'internement maintient une table de hachage qui contient toutes les chaînes internes encore accessibles . Lorsque vous appelez intern() sur une String , la méthode recherche l'objet dans la table de hachage:

  • Si la chaîne est trouvée, cette valeur est renvoyée sous la forme de la chaîne interne.
  • Sinon, une copie de la chaîne est ajoutée à la table de hachage et cette chaîne est renvoyée en tant que chaîne interne.

Il est possible d'utiliser l'internement pour permettre de comparer des chaînes en utilisant == . Cependant, cela pose des problèmes importants. voir Pitfall - Interner des chaînes pour pouvoir utiliser == est une mauvaise idée pour les détails. Ce n'est pas recommandé dans la plupart des cas.