Comparaison de chaînes en Java

Comparer des chaînes en Java

1. Vue d'ensemble

Dans cet article, nous allons parler des différentes façons de comparer lesStrings en Java.

CommeString 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. String Comparaison avec la classeString

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 de Java. Ceci est incorrect car“==” only checks the referential equality of two Strings, signifie s'ils 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éralString.

D'autre part, la deuxième assertion est fausse carstring1 est créé avec un littéral etstring3 est créé à l'aide de l'opérateurnew - ils font donc référence à des objets différents.

2.2. Utilisation deequals()

La classeString remplace lesequals() hérités deObject.This method compares two Strings character by character, ignoring their address.

Il les considère comme égaux s’ils ont la 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 variablesstring1, string2, etstring4 sont égales car elles ont la même casse et la même valeur quelle que soit leur adresse.

Pourstring3, la méthode renvoiefalse, car elle est sensible à la casse.

De plus, si l'une des deux chaînes estnull, la méthode renvoiefalse.

2.3. Utilisation deequalsIgnoreCase()

La méthodeequalsIgnoreCase() renvoie une valeur booléenne. Comme son nom l'indique, cette méthodeignores casing in characters while comparing Strings:

String string1 = "using equals ignore case";
String string2 = "USING EQUALS IGNORE CASE";

assertThat(string1.equalsIgnoreCase(string2)).isTrue();

2.4. Utilisation decompareTo()

La méthodecompareTo() renvoie une valeur de typeint etcompares two Strings character by character lexicographically basé sur un dictionnaire ou un ordre naturel.

Cette méthode renvoie 0 si deuxStrings sont égaux ou si les deux sontnull,un nombre négatif si le premierString précède l'argument, et un nombre supérieur à zéro si le premierString vient après l'argumentString.

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 decompareToIgnoreCase()

LecompareToIgnoreCase() 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. String Comparaison avec la classeObjects

Objects est une classe utilitaire qui contient une méthode statiqueequals(), utile dans ce scénario - pour comparer deuxStrings.

La méthode renvoietrue si deuxStrings sont égaux àfirstcomparing them using their address, c'est-à-dire «==”. Par conséquent, si les deux arguments sontnull, il renvoietrue et si exactement un argument estnull, il renvoie faux.

Sinon, il appelle alors simplement la méthodeequals() de la classe du type de l’argument passé - qui dans notre cas est la méthodeString’s classequals(). Cette méthode est sensible à la casse car elle appelle en interne la méthodeequals() de la classeString.

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. String Comparaison avecApache Commons

The Apache Commons library contains a utility class called StringUtils for String-related operations; cela a également des méthodes très avantageuses pour la comparaison deString.

4.1. Utilisation deequals() and equalsIgnoreCase ()

La méthodeequals() de la classeStringUtils est une version améliorée de la méthode de classeStringequals(), 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éthodeequalsIgnoreCase() deStringUtils renvoie une valeurboolean. Cela fonctionne de la même manière queequals(), sauf qu'il ignore la casse des caractères dansStrings:

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

4.2. Utilisation deequalsAny() et equalsAnyIgnoreCase ()

Le premier argument de la méthodeequalsAny() est unString et le second est un type multi-argsCharSequence. La méthode renvoietrue si l'un des autresStrings correspond par rapport au premier casString avec sensibilité.

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éthodeequalsAnyIgnoreCase() fonctionne de manière similaire à la méthodeequalsAny(), mais ignore également la casse:

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

4.3. Utilisation decompare() et compareIgnoreCase ()

La méthodecompare() dans la classeStringUtils est une méthodenull-safe version of the compareTo() de la classeString et gère les valeursnull parconsidering a null value less than a non-null value. Deux valeursnull sont considérés comme égaux.

De plus, cette méthode peut être utilisée pour trier une liste deStrings avec des entréesnull:

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éthodecompareIgnoreCase() 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 optionnullIsLess. C'esta third boolean argument which decides if null values should be considered less or not.

Une valeur denull est inférieure à un autreString sinullIsLess est vrai et supérieure sinullIsLess est faux.

Essayons-le:

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

La méthodecompareIgnoreCase() avec un troisième argumentboolean fonctionne de la même manière, sauf en ignorant la casse.

5. Conclusion

Dans ce rapide tutoriel, nous avons discuté de différentes manières de comparerStrings.

Et, comme toujours, le code source des exemples peut être trouvéover on GitHub.