Сравнение строк с Java

Введение В этом руководстве мы углубимся в сравнение строк в Java. Сравнение строк - обычная операция для всех языков. Возможность проверить, равна ли одна строка другой, позволяет нам выполнять фундаментальные проверки и изменять поток кода. Оператор '==' Оператор == - один из первых операторов, которым вы научились при погружении в новый язык, обычно для сравнения примитивных типов данных, таких как int. Давайте посмотрим, как мы можем сравнить два объекта String с оператором ==.

Вступление

В этом руководстве мы углубимся в сравнение строк в 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.

comments powered by Disqus