Автор оригинала: David Landup.
Вступление
В этом уроке мы рассмотрим сравнение строк в Java .
Сравнение строк является общей операцией на всех языках. Возможность проверить, равна ли одна строка другой, позволяет нам выполнять фундаментальные проверки и изменять поток кода.
Оператор ‘==’
Оператор == является одним из первых операторов, изучаемых при переходе на новый язык, как правило, для сравнения примитивных типов данных, таких как int s.
Давайте посмотрим, как мы можем сравнить два объекта String с оператором == :
String s1 = "Hello"; String s2 = "Hello"; String s3 = "World"; System.out.println(s1 == s2); System.out.println(s2 == s3);
Это вернулось бы:
true false
Это ожидается – s1 и s2 . Однако давайте немного перепишем это в:
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1 == s2);
Это возвращает:
false
Это связано с тем, что оператор == не проверяет равенство . Он проверяет личность .
Другими словами, он не сравнивает значение String s – он сравнивает ссылки на объекты.
s1 является ссылочной переменной на тот же объект в памяти, на который ссылается s2 . Это связано с тем, что Пул строк не создает новых объектов, если мы попытаемся создать экземпляр строки с уже существующим значением.
Однако, когда мы создаем экземпляр s2 с ключевым словом new , мы явно сообщаем JVM, что нам нужен новый объект. Затем, даже если они имеют одно и то же строковое значение – ссылочные переменные s1 и s2 ссылаются на разные объекты, и, следовательно, оператор == возвращает false .
Метод equals()
Метод equals() обычно используется при сравнении содержимого строк. Он чувствителен к регистру и сравнивает каждый символ строки с каждым символом другой строки:
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1.equals(s2));
Это всегда будет возвращаться:
true
Независимо от того , написали ли мы s1.равно(s2) или s2.равно(s1) , результат будет одинаковым.
функция equals() безопасна для null, что означает, что она проверяет для вас значения null . Если мы сравним значение, отличное от null , со значением null , логически, результат будет ложным :
String s1 = "Hello"; String s2 = null; System.out.println(s1.equals(s2));
false
Метод equalsIgnoreCase()
Поскольку equals() чувствителен к регистру, в таких случаях, как Привет и привет , он вернет false . Они действительно не равны, если важен случай. Однако в некоторых ситуациях дело действительно не имеет значения. Вы просто хотели бы проверить, совпадают ли сами символы, независимо от случая.
Для этого мы используем метод equalsIgnoreCase() :
String s1 = "Hello"; String s2 = "hello"; System.out.println(s1.equals(s2)); System.out.println(s1.equalsIgnoreCase(s2));
Это приводит к:
false true
Метод сравнения()
Метод compareTo() работает иначе, чем метод equals () . Метод compareTo() проверяет лексикографическое значение строки.
Если мы сравним s1 с s2 – если лексикографическое значение s1 выше, чем s2 , метод вернет положительное значение. Если он ниже, метод вернет отрицательное значение. Если они одинаковы, метод вернет 0 .
Этот метод очень полезен, если вы хотите отсортировать слова в лексикографическом порядке:
String s1 = "a"; String s2 = "b"; System.out.println(s1.compareTo(s2));
Это возвращает:
-1
Поскольку разница в значениях Юникода для a и b составляет всего 1. Давайте рассмотрим другой пример:
String s1 = "Hello World"; String s2 = "hello world"; System.out.println(s1.compareTo(s2));
Это приводит к:
-32
Метод compareToIgnoreCase()
Git Essentials
Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!
Аналогично, существует версия этого метода, которая не заботится о регистре символов. Например, две предыдущие строки:
String s1 = "Hello World"; String s2 = "hello world"; System.out.println(s1.compareToIgnoreCase(s2));
Теперь бы вернулся:
0
Метод contentEquals()
Метод content Equals() используется относительно редко, так как он выглядит так же, как метод equals () .
А именно, метод equals() сравнивает объекты на равенство. Класс String переопределяет поведение по умолчанию, чтобы сравнить содержимое.
содержимое равно() метод сравнивает последовательность символов s и Буферизатор строк s. С его помощью вам не нужно преобразовывать StringBuffer в Строку для сравнения – метод сам справится с этим:
String s1 = "aaaa";
StringBuffer s2 = new StringBuffer("");
for (int i = 0; i < 4; i++) {
s2.append('a');
}
System.out.println(s1.contentEquals(s2));
С помощью предыдущего метода вы не можете сравнить Строку с буфером строк . Таким образом, вы можете.
Этот код возвращает:
true
StringUtils – Apache Commons
Библиотека Apache Commons – это надежная библиотека, наполненная бесчисленными удобными методами и классами.
StringUtils -это вспомогательный класс с кучей операций, связанных со строками, в том числе для проверки равенства.
StringUtils.равно()
Метод equals() класса StringUtils работает так же, как мы ожидали бы, основываясь на нашем знакомстве с методом Object.equals() :
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(StringUtils.equals(s1, s2));
System.out.println(StringUtils.equals(s1, null));
System.out.println(StringUtils.equals(null, null));
Это вернулось бы:
true false true
Он также обеспечивает нулевую безопасность и проверяет наличие нулевых значений. Сравнение двух нулевых значений вернет true .
StringUtils.equalsIgnoreCase()
Метод equalsIgnoreCase() работает таким же образом:
String s1 = "Hello";
String s2 = new String("hello");
System.out.println(StringUtils.equalsIgnoreCase(s1, s2));
System.out.println(StringUtils.equalsIgnoreCase(s1, null));
System.out.println(StringUtils.equalsIgnoreCase(null, null));
Это возвращает:
true false true
StringUtils.equalsAny()
равно любому () – это первый метод, который делает что-то совершенно новое. Он принимает Строку и последовательность символов vararg. Если какие-либо из переменных можно найти в строке |, она возвращает значение true:
System.out.println(StringUtils.equalsAny("Hello World", "Hello", "World"));
System.out.println(StringUtils.equalsAny("Java is great!", "Java", "great!"));
Это вернулось бы:
true true
Примечание: Метод чувствителен к регистру.
StringUtils.equalsAnyIgnoreCase()
Конечно, у нас также есть вариант метода без учета регистра:
System.out.println(StringUtils.equalsAnyIgnoreCase("Hello World", "HELLO", "world"));
System.out.println(StringUtils.equalsAnyIgnoreCase("Java is great!", "JavA", "GrEat!"));
Они также вернутся:
true true
StringUtils.сравните()
Метод compare() класса StringUtils работает так же, как метод compareTo() класса String|/. Однако этот удобный метод безопасен для нуля в отличие от официальной реализации.
Это следует идее о том, что значение null лексикографически меньше, чем значение, не являющееся null , что имеет большой смысл.
String s1 = "a"; String s2 = "b"; System.out.println(StringUtils.compare(s1, s2));
Это возвращает:
-1
StringUtils.compareIgnoreCase()
Наконец, версия предыдущего метода без учета регистра- compareIgnoreCase() . Он сравнивает лексикографическое значение строк, не принимая во внимание регистр:
String s1 = "A"; String s2 = "a"; System.out.println(StringUtils.compareIgnoreCase(s1, s2));
Это обычно возвращается -32 так как строчные буквы отделены от их заглавных аналогов 32 местами. Однако это возвращает:
0
Вывод
Сравнение строк в Java, как и в других языках, является обычной задачей. Существует довольно много способов сделать это, как с помощью встроенных методов, так и с помощью библиотеки Apache Commons.