Comparaison de chaînes en Java

1. Vue d'ensemble

Dans cet article, nous parlerons des différentes façons de comparer des chaînes en Java.

Comme String est l'un des types de données les plus utilisés en Java, il s'agit naturellement d'une opération très couramment utilisée.

2. Chaîne Comparaison avec chaîne de classe

2.1. Utilisation de l’ opérateur de comparaison «==»

L'utilisation de l'opérateur «==» pour comparer les valeurs de texte est l'une des erreurs les plus courantes commises par les débutants en Java. Ceci est incorrect car «==» ne vérifie que l'égalité référentielle de deux chaînes , c'est-à-dire si elles font référence au même objet ou non.

Voyons un exemple de ce comportement:

String string1 = "using comparison operator"; String string2 = "using comparison operator"; String string3 = new String("using comparison operator"); assertThat(string1 == string2).isTrue(); assertThat(string1 == string3).isFalse();

Dans l'exemple ci-dessus, la première assertion est vraie car les deux variables pointent vers le même littéral String .

D'autre part, la deuxième assertion est fausse car string1 est créé avec un littéral et string3 est créé à l'aide de l' opérateur new - par conséquent, ils référencent différents objets.

2.2. Utilisation d' égaux ()

La classe String remplace equals () héritée d' Object. Cette méthode compare deux chaînes caractère par caractère, en ignorant leur adresse.

Il les considère égaux s'ils sont de même longueur et que les caractères sont dans le même ordre:

String string1 = "using equals method"; String string2 = "using equals method"; String string3 = "using EQUALS method"; String string4 = new String("using equals method"); assertThat(string1.equals(string2)).isTrue(); assertThat(string1.equals(string4)).isTrue(); assertThat(string1.equals(null)).isFalse(); assertThat(string1.equals(string3)).isFalse();

Dans cet exemple, les variables string1 , string2 et string4 sont égales car elles ont la même casse et la même valeur quelle que soit leur adresse.

Pour string3, la méthode renvoie false, car elle est sensible à la casse.

De plus, si l'une des deux chaînes est nulle , la méthode renvoie false.

2.3. Utilisation de equalsIgnoreCase ()

La méthode equalsIgnoreCase () renvoie une valeur booléenne. Comme son nom l'indique, cette méthode ignore la casse des caractères lors de la comparaison des chaînes :

String string1 = "using equals ignore case"; String string2 = "USING EQUALS IGNORE CASE"; assertThat(string1.equalsIgnoreCase(string2)).isTrue();

2.4. Utilisation de compareTo ()

La méthode compareTo () renvoie une valeur de type int et compare deux chaînes caractère par caractère lexicographiquement en fonction d'un dictionnaire ou d'un ordre naturel.

Cette méthode renvoie 0 si deux chaînes sont égales ou si les deux sont nulles, un nombre négatif si la première chaîne précède l'argument et un nombre supérieur à zéro si la première chaîne vient après l'argument String.

Voyons un exemple:

String author = "author"; String book = "book"; String duplicateBook = "book"; assertThat(author.compareTo(book)) .isEqualTo(-1); assertThat(book.compareTo(author)) .isEqualTo(1); assertThat(duplicateBook.compareTo(book)) .isEqualTo(0);

2.5. Utilisation de compareToIgnoreCase ()

Le compareToIgnoreCase () est similaire à la méthode précédente, sauf qu'il ignore la casse:

String author = "Author"; String book = "book"; String duplicateBook = "BOOK"; assertThat(author.compareToIgnoreCase(book)) .isEqualTo(-1); assertThat(book.compareToIgnoreCase(author)) .isEqualTo(1); assertThat(duplicateBook.compareToIgnoreCase(book)) .isEqualTo(0);

3. Comparaison de chaînes avec la classe d' objets

Objects est une classe utilitaire qui contient une méthode statique equals () , utile dans ce scénario - pour comparer deux chaînes.

La méthode renvoie true si deux chaînes sont égales en les comparant d' abord à l'aide de leur adresse, c'est- à- dire « ==» . Par conséquent, si les deux arguments sont nuls , il renvoie vrai et si exactement un argument est nul , il renvoie faux.

Sinon, il appelle alors simplement la méthode equals () de la classe du type de l'argument passé - qui dans notre cas est la méthode equals () de la classe String . Cette méthode est sensible à la casse car elle appelle en interne la méthode equals () de la classe String .

Testons ceci:

String string1 = "using objects equals"; String string2 = "using objects equals"; String string3 = new String("using objects equals"); assertThat(Objects.equals(string1, string2)).isTrue(); assertThat(Objects.equals(string1, string3)).isTrue(); assertThat(Objects.equals(null, null)).isTrue(); assertThat(Objects.equals(null, string1)).isFalse();

4. Comparaison de chaînes avec Apache Commons

La bibliothèque Apache Commons contient une classe utilitaire appelé StringUtils pour String- opérations connexes ; cela a également des méthodes très utiles pour la comparaison de chaînes .

4.1. Utilisation de equals () et equalsIgnoreCase ()

La méthode equals () de la classe StringUtils est une version améliorée de la méthode de classe String equals (), qui gère également les valeurs nulles:

assertThat(StringUtils.equals(null, null)) .isTrue(); assertThat(StringUtils.equals(null, "equals method")) .isFalse(); assertThat(StringUtils.equals("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equals("equals method", "EQUALS METHOD")) .isFalse();

La méthode equalsIgnoreCase () de StringUtils renvoie une valeur booléenne . Cela fonctionne de la même manière que equals (), sauf qu'il ignore la casse des caractères dans Strings:

assertThat(StringUtils.equalsIgnoreCase("equals method", "equals method")) .isTrue(); assertThat(StringUtils.equalsIgnoreCase("equals method", "EQUALS METHOD")) .isTrue();

4.2. Utilisation de equalsAny () et equalsAnyIgnoreCase ()

Le premier argument de la méthode equalsAny () est un String et le second est un type CharSequence multi-args . La méthode retourne true si l'une des autres chaînes données correspond à la première chaîne de manière sensible.

Sinon, false est renvoyé:

assertThat(StringUtils.equalsAny(null, null, null)) .isTrue(); assertThat(StringUtils.equalsAny("equals any", "equals any", "any")) .isTrue(); assertThat(StringUtils.equalsAny("equals any", null, "equals any")) .isTrue(); assertThat(StringUtils.equalsAny(null, "equals", "any")) .isFalse(); assertThat(StringUtils.equalsAny("equals any", "EQUALS ANY", "ANY")) .isFalse();

La méthode equalsAnyIgnoreCase () fonctionne de la même manière que la méthode equalsAny () , mais ignore également la casse:

assertThat(StringUtils.equalsAnyIgnoreCase("ignore case", "IGNORE CASE", "any")).isTrue();

4.3. Utilisation de compare () et compareIgnoreCase ()

La méthode compare () de la classe StringUtils est une version de sécurité null de la méthode compareTo () de la classe String et gère les valeurs nulles en considérant une valeur nulle inférieure à une valeur non nulle . Deux valeurs nulles sont considérées comme égales.

De plus, cette méthode peut être utilisée pour trier une liste de chaînes avec des entrées nulles :

assertThat(StringUtils.compare(null, null)) .isEqualTo(0); assertThat(StringUtils.compare(null, "abc")) .isEqualTo(-1); assertThat(StringUtils.compare("abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compare("bbc", "abc")) .isEqualTo(1);

La méthode compareIgnoreCase () se comporte de la même manière, sauf qu'elle ignore la casse:

assertThat(StringUtils.compareIgnoreCase("Abc", "bbc")) .isEqualTo(-1); assertThat(StringUtils.compareIgnoreCase("bbc", "ABC")) .isEqualTo(1); assertThat(StringUtils.compareIgnoreCase("abc", "ABC")) .isEqualTo(0);

Les deux méthodes peuvent également être utilisées avec une option nullIsLess . Il s'agit d' un troisième argument booléen qui décide si les valeurs nulles doivent être considérées comme inférieures ou non .

Une valeur nulle est inférieure à une autre chaîne si nullIsLess est true et supérieure si nullIsLess est false.

Essayons-le:

assertThat(StringUtils.compare(null, "abc", true)) .isEqualTo(-1); assertThat(StringUtils.compare(null, "abc", false)) .isEqualTo(1);

La méthode compareIgnoreCase () avec un troisième argument booléen fonctionne de la même manière, sauf en ignorant la casse.

5. Conclusion

Dans ce rapide didacticiel, nous avons discuté de différentes façons de comparer des chaînes.

Et, comme toujours, le code source des exemples est disponible sur GitHub.