Вступление
В этом руководстве мы углубимся в сравнение строк в 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 и s2 != s3 . Однако давайте немного
перепишем это так:
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1 == s2);
Это возвращает:
false
Это потому, что
==не проверяет равенство . Он проверяет личность .
Другими словами, он не сравнивает значение String s - он сравнивает
ссылки на объекты.
s1 - это ссылочная переменная для того же объекта в памяти, на который
ссылается s2 Это связано с тем, что пул строк не создает новые
объекты, если мы пытаемся создать экземпляр строки с уже существующим
значением.
Однако, когда мы создаем экземпляр s2 с new , мы явно сообщаем JVM,
что нам нужен новый объект. Тогда, даже если они имеют одинаковое
значение String - s1 и s2 относятся к разным объектам, и, таким
образом, оператор == false .
equals () Метод
Метод equals() обычно используется при сравнении содержимого строк. Он
чувствителен к регистру и сравнивает каждый символ строки с каждым
символом другой строки:
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1.equals(s2));
Это всегда будет возвращать:
true
Независимо от того, написали ли мы s1.equals(s2) или s2.equals(s1) ,
результат будет одинаковым.
equals() является нулевым, что означает, что он проверяет для вас
null значения. Если мы сравним null значение с null значением,
логически результат будет false :
String s1 = "Hello";
String s2 = null;
System.out.println(s1.equals(s2));
false
equalsIgnoreCase () Метод
Поскольку equals() чувствителен к регистру, в таких случаях, как
Hello и hello , он вернет false . Они действительно не равны, если
важен случай. Однако в некоторых ситуациях дело действительно не важно.
Вы просто хотите проверить, одинаковы ли сами символы, независимо от
регистра.
Для этого мы используем метод equalsIgnoreCase() :
String s1 = "Hello";
String s2 = "hello";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));
Это приводит к:
false
true
compareTo () Метод
Метод compareTo() работает иначе, чем метод equals() . Метод
compareTo() проверяет лексигографическое значение String.
Если мы сравним s1 с s2 - если s1 выше, чем s2 , метод вернет
положительное значение. Если оно ниже, метод вернет отрицательное
значение. Если они совпадают, метод вернет 0 .
Этот метод очень полезен, если вы хотите отсортировать слова в лексикографическом порядке:
String s1 = "a";
String s2 = "b";
System.out.println(s1.compareTo(s2));
Это возвращает:
-1
Поскольку разница в значениях Unicode для a и b составляет всего 1.
Давайте посмотрим на другой пример:
String s1 = "Hello World";
String s2 = "hello world";
System.out.println(s1.compareTo(s2));
Это приводит к:
-32
compareToIgnoreCase () Метод
Точно так же есть версия этого метода, которая не заботится о регистре символов. Например, предыдущие две строки:
String s1 = "Hello World";
String s2 = "hello world";
System.out.println(s1.compareToIgnoreCase(s2));
Теперь вернусь:
0
contentEquals () Метод
contentEquals() - относительно редко используемый метод, поскольку он
выглядит так же, как метод equals() .
А именно, метод equals() сравнивает объекты на предмет равенства.
Класс String переопределяет поведение по умолчанию, чтобы он сравнивал
содержимое.
contentEquals() метод сравнивает CharSequence с и StringBuffer ,
с. С его помощью вам не нужно преобразовывать StringBuffer в String
для сравнения - метод сам справится с этим:
String s1 = "aaaa";
StringBuffer s2 = new StringBuffer("");
for (int i = 0; i < 4; i++) {
s2.append('a');
}
System.out.println(s1.contentEquals(s2));
С помощью метода, описанного ранее, вы не можете сравнить String с
StringBuffer . Таким образом, ты сможешь.
Этот код возвращает:
true
StringUtils - Apache Commons
Библиотека Apache Commons - это надежная библиотека, наполненная бесчисленным множеством удобных методов и классов.
StringUtils - это вспомогательный класс с множеством операций,
связанных со String, в том числе для проверки равенства.
StringUtils.equals ()
Метод 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
Он также имеет нулевую безопасность и проверяет null значения.
Сравнение двух null значений вернет 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 ()
equalsAny() - это первый метод, который делает что-то совершенно
новое. Он принимает String и CharSequence vararg. Если какой-либо
из varargs можно найти в String , он возвращает 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 ()
Метод 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.