User Professor Hans Noodles
Professor Hans Noodles
41 уровень

Equals в Java и String compare - Сравнение строк

Статья из группы Java Developer
Привет! Сегодня мы поговорим об очень важной и интересной теме, а именно — сравнении объектов между собой equals() в Java. И действительно, в каких случаях в Java Объект А будет равен Объекту Б? Equals и сравнение строк  - 1Давай попробуем написать пример:

public class Car {

   String model;
   int maxSpeed;

   public static void main(String[] args) {
      
       Car car1 = new Car();
       car1.model = "Ferrari";
       car1.maxSpeed = 300;

       Car car2 = new Car();
       car2.model = "Ferrari";
       car2.maxSpeed = 300;

       System.out.println(car1 == car2);
   }
}
Вывод в консоль:

false
Так, стоп. А почему, собственно, эти две машины не равны? Мы задали им одинаковые свойства, но результат сравнения — false. Ответ прост. Оператор == сравнивает не свойства объектов, а ссылки. Будь у двух объектов даже 500 одинаковых свойств, результатом сравнения все равно будет false. Ведь ссылки car1 и car2 указывают на два разных объекта, на два разных адреса. Представь себе ситуацию со сравнением людей. В мире наверняка есть человек, у которого одинаковые с тобой имя, цвет глаз, возраст, рост, цвет волос и т.д. То есть вы во многом похожи, но все-таки вы не близнецы, и тем более не один и тот же человек. Equals и сравнение строк  - 2Примерно такую логику применяет оператор ==, когда с его помощью мы пытаемся сравнить два объекта. Но что, если в твоей программе тебе нужна другая логика? Например, если твоя программа симулирует анализ ДНК. Она должна сравнить код ДНК двух людей, и определить, что это близнецы.

public class Man {

   int dnaCode;

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.dnaCode = 1111222233;

       Man man2 = new Man();
       man2.dnaCode = 1111222233;

       System.out.println(man1 == man2);
   }
}
Вывод в консоль:

false
Логично, что результат получился тот же самый (ведь мы особо ничего не меняли), но теперь он нас не устраивает! Ведь в реальной жизни анализ ДНК — стопроцентная гарантия того, что перед нами близнецы. Но наша программа и оператор == говорят нам об обратном. Как нам изменить это поведение и сделать так, чтобы в случае совпадения анализов ДНК программа выдавала правильный результат? Для этого в Java был создан специальный метод — equals().

Метод Equals() в Java

Как и метод toString(), который мы разбирали ранее, equals() принадлежит классу Object самому главному классу в Java, от которого происходят все остальные классы. Однако сам по себе equals() никак не изменит поведение нашей программы:

public class Man {

   String dnaCode;

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.dnaCode = "111122223333";

       Man man2 = new Man();
       man2.dnaCode = "111122223333";

       System.out.println(man1.equals(man2));
   }
}
Вывод в консоль:

false
Точно такой же результат, ну и зачем тогда нужен этот метод? :/ Все просто. Дело в том, что сейчас мы использовали этот метод так, как он реализован в самом классе Object. И если мы зайдем в код класса Object и посмотрим, как в нем реализован данный метод и что он делает, то увидим:

public boolean equals(Object obj) {
   return (this == obj);
}
Вот и причина, почему поведение нашей программы не изменилось! Внутри метода equals() класса Object лежит то же самое сравнение ссылок, ==. Но фишка этого метода в том, что мы можем его переопределить. Переопределить — значит написать свой метод equals() в нашем классе Man и сделать его поведение таким, какое нам нужно! Сейчас нас не устраивает, что проверка man1.equals(man2), по сути, делает то же, что и man1 == man2. Вот что мы сделаем в такой ситуации:

public class Man {

   int dnaCode;

   public boolean equals(Man man) {
       return this.dnaCode ==  man.dnaCode;
   }

   public static void main(String[] args) {

       Man man1 = new Man();
       man1.dnaCode = 1111222233;

       Man man2 = new Man();
       man2.dnaCode = 1111222233;

       System.out.println(man1.equals(man2));

   }
}
Вывод в консоль:

true
Совсем другой результат! Написав свой метод equals() вместо стандартного, мы добились правильного поведения: теперь если у двух людей одинаковый код ДНК, программа говорит нам: “Анализ ДНК показал, что это близнецы” и возвращает true! Переопределяя метод equals() в своих классах, ты можешь легко создавать нужную логику сравнения объектов. Мы затронули сравнение объектов только в общих чертах. Впереди у нас еще будет отдельная большая лекция на эту тему (можешь бегло прочесть ее уже сейчас, если интересно).

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

Почему мы рассматриваем сравнение строк отдельно от всего остального? Ну, на самом деле, строки в программировании — вообще отдельная песня. Во-первых, если взять все написанные человечеством программы на Java, порядка 25% объектов в них составляют именно они. Поэтому данная тема очень важна. Во-вторых, процесс сравнения строк действительно сильно отличается от остальных объектов. Рассмотрим простой пример:

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = new String("JavaRush - лучший сайт для изучения Java!");
       System.out.println(s1 == s2);
   }
}
Вывод в консоль:

false
Но почему false? Строки-то ведь абсолютно одинаковые, слово-в-слово :/ Ты можешь предположить: это потому что оператор == сравнивает ссылки! Ведь у s1 и s2 разные адреса в памяти. Если тебя посетила такая мысль, то давай переделаем наш пример:

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = "JavaRush - лучший сайт для изучения Java!";
       System.out.println(s1 == s2);
   }
}
Сейчас у нас тоже две ссылки, но вот результат изменился на противоположный: Вывод в консоль:

true
Окончательно запутался? :) Давай разбираться. Оператор == действительно сравнивает адреса в памяти. Это правило работает всегда и в нем не надо сомневаться. Значит, если s1 == s2 возвращает true, у этих двух строк одинаковый адрес в памяти. И это действительно так! Настало время познакомиться со специальной областью памяти для хранения строк — пулом строк (String pool) Equals и сравнение строк  - 3Пул строк — область для хранения всех строковых значений, которые ты создаешь в своей программе. Для чего он был создан? Как и говорилось раньше, строки занимают огромную часть от всех объектов. В любой большой программе создается очень много строк. С целью экономии памяти и нужен String Pool — туда помещается строка с нужным тебе текстом, и в дальнейшем вновь созданные ссылки ссылаются на одну и ту же область памяти, нет нужды каждый раз выделять дополнительную память. Каждый раз, когда ты пишешь String = “........”, программа проверяет, есть ли строка с таким текстом в пуле строк. Если есть — новая создана не будет. И новая ссылка будет указывать на тот же адрес в пуле строк, где эта строка хранится. Поэтому когда мы написали в программе

String s1 = "JavaRush - лучший сайт для изучения Java!";
String s2 = "JavaRush - лучший сайт для изучения Java!";
ссылка s2 указывает ровно туда же, куда и s1. Первая команда создала в пуле строк новую строку с нужным нам текстом, а когда дело дошло до второй — она просто сослалась на ту же область памяти, что и s1. Можно сделать хоть еще 500 строк с таким же текстом, результат не изменится. Стоп. Но почему тогда ранее у нас не сработал этот пример?

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = new String("JavaRush - лучший сайт для изучения Java!");
       System.out.println(s1 == s2);
   }
}
Думаю, интуитивно ты уже догадываешься в чем причина :) Попробуй предположить, прежде чем читать дальше. Ты видишь, что эти две строки были созданы по-разному. Одна — с помощью оператора new, а вторая без него. Именно в этом кроется причина. Оператор new при создании объекта принудительно выделяет для него новую область в памяти. И строка, созданная с помощью new, не попадает в String Pool: она становится отдельным объектом, даже если ее текст полностью совпадает с такой же строкой из String Pool’a. То есть если мы напишем такой код:

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = "JavaRush - лучший сайт для изучения Java!";
       String s3 = new String("JavaRush - лучший сайт для изучения Java!");
   }
}
В памяти это будет выглядеть вот так: Equals и сравнение строк  - 4И каждый раз при создании нового объекта через new в памяти будет выделяться новая область, даже если текст внутри новых строк будет одинаковым! С оператором == вроде разобрались, а что с нашим новым знакомым — методом equals()?

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = new String("JavaRush - лучший сайт для изучения Java!");
       System.out.println(s1.equals(s2));
   }
}
Вывод в консоль:

true
Интересно. Мы точно знаем, что s1 и s2 указывают на разные области в памяти. Но, тем не менее, метод equals() говорит, что они равны. Почему? Помнишь, выше мы говорили о том, что метод equals() можно переопределить в своем классе, чтобы он сравнивал объекты так, как тебе нужно? С классом String так и поступили. У него есть переопределенный метод equals(). И сравнивает он не ссылки, а именно последовательность символов в строках. И если текст в строках одинаковый, неважно, как они были созданы и где хранятся: в пуле строк, или в отдельной области памяти. Результатом сравнения будет true. Кстати, Java позволяет корректно сравнивать строки без учета регистра. В обычной ситуации, если написать одну из строк, например, капсом, то результатом сравнения будет false:

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = new String("JAVARUSH - ЛУЧШИЙ САЙТ ДЛЯ ИЗУЧЕНИЯ JAVA!");
       System.out.println(s1.equals(s2));
   }
}
Вывод в консоль:

false
Для этого случая в классе String имеется метод equalsIgnoreCase(). Если в твоем сравнении главным является именно последовательность конкретных символов, а не их регистр, можно применить его. Например, это будет полезно при сравнении двух почтовых адресов:

public class Main {

   public static void main(String[] args) {

       String address1 = "г. Москва, ул. Академика Королева, дом 12";
       String address2 = new String("Г. МОСКВА, УЛ. АКАДЕМИКА КОРОЛЕВА, ДОМ 12");
       System.out.println(address1.equalsIgnoreCase(address2));
   }
}
В данном случае очевидно, что речь идет об одном и том же адресе, поэтому использование метода equalsIgnoreCase() будет верным решением.

Метод String.intern()

У класса String есть еще один хитрый метод — intern(); Метод intern() напрямую работает со String Pool’ом. Если ты вызываешь метод intern() у какой-то строки, он:
  • Смотрит, есть ли строка с таким текстом в пуле строк
  • Если есть — возвращает ссылку на нее в пуле
  • Если же нет — помещает строку с этим текстом в пул строк и возвращает ссылку на нее.
Применив метод intern() к ссылке на строку, которая создавалась через new, мы можем сравнивать ее со ссылкой на строку из String Pool’a через оператор ==.

public class Main {

   public static void main(String[] args) {

       String s1 = "JavaRush - лучший сайт для изучения Java!";
       String s2 = new String("JavaRush - лучший сайт для изучения Java!");
       System.out.println(s1 == s2.intern());
   }
}
Вывод в консоль:

true
Раньше, когда мы сравнивали их без intern(), результат был равен false. Теперь же метод intern() проверил, есть ли строка с текстом "JavaRush — лучший сайт для изучения Java!" в пуле строк. Разумеется, она там есть: мы создали ее, когда написали

String s1 = "JavaRush — лучший сайт для изучения Java!";
Была проведена проверка, что ссылка s1 и ссылка, возвращенная методом s2.intern() указывают на одну область в памяти, и, конечно, так оно и есть:) Подводя итоги, запомни и используй главное правило: Для сравнения строк ВСЕГДА используй метод equals()! Сравнивая строки, ты почти всегда имеешь в виду сравнение их текста, а не ссылок, областей памяти и прочего. Метод equals() делает именно то, что тебе нужно. Equals и сравнение строк  - 5Вот тебе несколько ссылок для самостоятельного изучения:
Комментарии (196)
ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ
Igor Makarov Уровень 16, Хабаровск, Russian Federation
27 апреля 2022
Я смотрел всякие другие курсы, везде про new говорили, мол выделает память, НО где, как и почему, не говорили, бери знание как данность и отстань, а вы парни объяснили, как говориться: что бы чему то научить нужно усердие, а что бы делиться знаниями, усердия мало, нужно еще - благородие!
ForJavaRush Уровень 6
23 апреля 2022
Если коротко про ".intern()" то для экономии ресурсов он ищет просто внутри пула? Если не находит то просто туда добавляет...?
PHANTOM Уровень 7, Москва, Russian Federation
18 апреля 2022
Я не совсем понимаю. Для чего тогда нужен метод .equals? Да, я понял что этот метод сравнивает текст, но. Например: В лекции говорится что если мы сравним нижеприведенные строки методом .equals, это будет true и это я понял. Но если мы изменим например регистр в одной строке, то с методом .equals это будет уже false и это тоже ясно. (Текст то разный) String s1 = "JavaRush - лучший сайт для изучения Java!"; String s2 = "JavaRush - лучший сайт для изучения Java!"; Если мы будем сравнивать адреса оператором == то это будет true т.к s1 будет ссылаться на s2, а если мы например изменим текст в переменной s2, и сравним оператором s1 == s2, то это будет false потому что для оператора s2 выделится новая область памяти. Так вот и непонятно зачем нужен метод .equals если по сути при изменении текста в обоих случаях будет false, в первом == из за того что адрес стал ссылаться на разные области в памяти, а во втором .equals из за того что текст разный
Shekerbek Уровень 51, Бишкек, Kyrgyzstan
6 марта 2022
Good work
Andrei Уровень 26, Молдавия
24 февраля 2022
Метод toEquals() не переопределен. Он перезагружен (overloaded). Его параметр должен быть типа Object. Если ты создашь:

Object man3 = new Man();
man3.dnaCode = 1111222233;
System.out.println(man2.equals(man3));
Что будет выводится в консоли?
Anonymous #2946557 Уровень 6, Russian Federation
2 февраля 2022
Прочитал статью и больше запутался....то equals false вначале показывает на примере с ДНК а в конце он оказывается самый точный для проверки именно наполнения строки....что не так читаю не понял...
Sanfelix Уровень 10, Russian Federation
27 января 2022
ОООО! Вот это разъяснение. Вот теперь все понятно. Спасибо
Anonymous #2924261 Уровень 4
20 января 2022
Здесь изучить материал не удалось про сравнение строк Срок регистрации домена истек
Андрей Уровень 28, Москва
17 января 2022
Статья очень полезная и разжеванная, спасибо!
Alexander Уровень 3, Москва, Russian Federation
16 января 2022
Отличная статья !!!