Java — Сравнение слов


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

Что означает «сравнить две строки лексикографически»?

Исходя из ответов @Bozho и @aioobe, лексикографические сравнения похожи на порядок, который можно найти в словаре.

Класс Java String предоставляет метод .compareTo () для лексикографического сравнения строк. Он используется так «apple».compareTo («banana») .

Возвращением этого метода является int , который можно интерпретировать следующим образом:

  • возвращает & lt; 0 тогда строка, вызывающая метод, сначала лексикографически (сначала в словаре)
  • возвращает == 0, тогда две строки лексикографически эквивалентны
  • возвращает> 0, затем параметр, переданный методу compareTo , сначала лексикографически.

Более конкретно, метод обеспечивает первую ненулевую разницу в значениях ASCII.

Таким образом, «computer».compareTo («comparison») вернет значение (int) ‘u’ — (int) ‘a’ (20). Поскольку это положительный результат, параметр ( «comparison» ) в первую очередь лексикографически.

Существует также вариант .compareToIgnoreCase () , который, например, будет возвращать 0 для «a».compareToIgnoreCase («A»); .

Java — Сравнение слов

Для соединения строк можно использовать операцию сложения («+»):

При этом если в операции сложения строк используется нестроковый объект, например, число, то этот объект преобразуется к строке:

Фактически же при сложении строк с нестроковыми объектами будет вызываться метод valueOf() класса String. Данный метод имеет множество перегрузок и преобразует практически все типы данных к строке. Для преобразования объектов различных классов метод valueOf вызывает метод toString() этих классов.

Другой способ объединения строк представляет метод concat() :

Метод concat() принимает строку, с которой надо объединить вызывающую строку, и возвращает соединенную строку.

Еще один метод объединения — метод join() позволяет объединить строки с учетом разделителя. Например, выше две строки сливались в одно слово «HelloJava», но в идеале мы бы хотели, чтобы две подстроки были разделены пробелом. И для этого используем метод join() :

Метод join является статическим. Первым параметром идет разделитель, которым будут разделяться подстроки в общей строке, а все последующие параметры передают через запятую произвольный набор объединяемых подстрок — в данном случае две строки, хотя их может быть и больше

Извлечение символов и подстрок

Для извлечения символов по индексу в классе String определен метод char charAt(int index) . Он принимает индекс, по которому надо получить символов, и возвращает извлеченный символ:

Как и в массивах индексация начинается с нуля.

Если надо извлечь сразу группу символов или подстроку, то можно использовать метод getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) . Он принимает следующие параметры:

srcBegin : индекс в строке, с которого начинается извлечение символов

srcEnd : индекс в строке, до которого идет извлечение символов

dst : массив символов, в который будут извлекаться символы

dstBegin : индекс в массиве dst, с которого надо добавлять извлеченные из строки символы

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

Для сравнения строк используются методы equals() (с учетом регистра) и equalsIgnoreCase() (без учета регистра). Оба метода в качестве параметра принимают строку, с которой надо сравнить:

В отличие от сравнения числовых и других данных примитивных типов для строк не применяется знак равенства ==. Вместо него надо использовать метод equals() .

Еще один специальный метод regionMatches() сравнивает отдельные подстроки в рамках двух строк. Он имеет следующие формы:

Метод принимает следующие параметры:

ignoreCase : надо ли игнорировать регистр символов при сравнении. Если значение true , регистр игнорируется

toffset : начальный индекс в вызывающей строке, с которого начнется сравнение

other : строка, с которой сравнивается вызывающая

oofset : начальный индекс в сравниваемой строке, с которого начнется сравнение

len : количество сравниваемых символов в обеих строках

В данном случае метод сравнивает 3 символа с 6-го индекса первой строки («wor») и 3 символа со 2-го индекса второй строки («wor»). Так как эти подстроки одинаковы, то возвращается true .

И еще одна пара методов int compareTo(String str) и int compareToIgnoreCase(String str) также позволяют сравнить две строки, но при этом они также позволяют узнать больше ли одна строка, чем другая или нет. Если возвращаемое значение больше 0, то первая строка больше второй, если меньше нуля, то, наоборот, вторая больше первой. Если строки равны, то возвращается 0.

Для определения больше или меньше одна строка, чем другая, используется лексикографический порядок. То есть, например, строка «A» меньше, чем строка «B», так как символ ‘A’ в алфавите стоит перед символом ‘B’. Если первые символы строк равны, то в расчет берутся следующие символы. Например:

Поиск в строке

Метод indexOf() находит индекс первого вхождения подстроки в строку, а метод lastIndexOf() — индекс последнего вхождения. Если подстрока не будет найдена, то оба метода возвращают -1:


Метод startsWith() позволяют определить начинается ли строка с определенной подстроки, а метод endsWith() позволяет определить заканчивается строка на определенную подстроку:

Замена в строке

Метод replace() позволяет заменить в строке одну последовательность символов на другую:

Обрезка строки

Метод trim() позволяет удалить начальные и конечные пробелы:

Метод substring() возвращает подстроку, начиная с определенного индекса до конца или до определенного индекса:

Изменение регистра

Метод toLowerCase() переводит все символы строки в нижний регистр, а метод toUpperCase() — в верхний:

Split

Метод split() позволяет разбить строку на подстроки по определенному разделителю. Разделитель — какой-нибудь символ или набор символов передается в качестве параметра в метод. Например, разобьем текст на отдельные слова:

В данном случае строка будет разделяться по пробелу. Консольный вывод:

Useful blog

Linux, Java, Python, Php, Javascript, FTP, SSH, HTTP, настройки, конфигурирование, администрирование и т.п. Всё, с чем приходится сталкиваться.

четверг, 4 марта 2010 г.

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

Встала передо мной задача, сравнить пару строчек в Java.
Выглядело это примерно так:

String str1 = new String(«Test»);
String str2 = new String(«Test»);
if (str1 == str2)
System.out.println(«Строчки совпадают!»);

Однако, сообщение «Строчки совпадают!» не появилось.
Казалось бы, как так может быть, строки-то ведь одинаковые.
Разгадка же проста: при сравнении с помощью «==» в реальности сравниваются указатели на строки, а, так как str1 и str2 указывают на строки, находящиеся в разных местах памяти, они не равны друг другу.
Спасибо юзеру incrab, указавшему на мою ошибку в первоначальном варианте поста.
Если бы мы делали следующее:

String str1 = «Test»;
String srt2 = str1;
if (str1 == str2)
System.out.println(«Строчки совпадают!»);

то сообщение бы вывелось, так как и str1 и str2 указывают на одну и ту же строку. (Проверить это можно, изменив str1, например str1 = «New string». Тогда, при выводе str2 на экран выведется не «Test», а «New string».

Цукерберг рекомендует:  Php - Создание папки при регистрации

Так как же все-таки сравнить то, что находится по указателям?
У класса String существует специальный метод equals, переопределенный из класса object , возвращает true , если аргумент obj не равен null , является объектом класса string , и строка, содержащаяся в нем, полностью идентична данной строке вплоть до совпадения регистра букв. В остальных случаях возвращается значение false.

Пользоваться им можно, например, так:

Сравнение строк в Java: string.compareTo и Collator

В мире существует огромное количество языков и диалектов. Каждый со своими особенностями и алфавитом. Некоторые даже используют письмо справа налево, а не слева направо.

Вы, наверное, также как и я сравнивали всю жизнь строки в Java с помощью метода compareTo в String:

В консоли будет выведено:

Этот метод осуществляет сортировку в соответствии с кодом символа в Юникод, то есть для большинства языков (и для русского в том числе) сравнение получается вполне корректным. Про метод compareTo и другие методы в классе String можно прочесть в моём учебнике.

Но сортировка получается правильной не для всех. Для правильного сравнения строк нужно обязательно учитывать язык, на котором написаны эти строки, то есть нужно учитывать Locale. В метод compareTo нельзя передать Locale, для правильного сравнения строк в соответствии с конкретной локалью нужно использовать класс java.text.Collator:

Использовать Collator для сравнения строк на английском языке особого смысла нет, да и для русского он не особо полезен. Он может быть полезен в случаях, когда вы используете какой-нибудь более экзотический язык.

Также Collator может пригодиться, если вам нужно сравнивать строки так, чтобы буквы «ё» и «е» считались одинаковыми. Для этого нужно использовать метод setStrength, который имеет параметр, влияющий на сравнение. Параметр может принимать четыре значения, воздействие которых зависит от Locale для которого создан Collator. Вот эти четыре значения: PRIMARY, SECONDARY, TERTIARY и IDENTICAL. Пример кода, который сравнивает строки, считая «Ё» и «Е» идентичными буквами, а также не учитывает регистр символов:

Java. Сравнение объектов с оператором equals()

Существует два способа сравнить объекты в языке Java:

  • Оператор ==
  • Оператор equals()

Сравнить объекты оператором equals() можно следующим образом:

Метод equals() принадлежит типу Object , который является предком каждого класса в языке Java. Это означает, что любой созданный вами класс будет наследовать базовое поведение equals() от Object . Это базовое поведение не отличается от оператора == . Другими словами, по умолчанию эти два выражения используют оператор == и возвращают значение false :

Посмотрите на метод spendMoney() класса Adult снова. Что происходит за кулисами, когда мы вызываем метод contains() нашей переменной wallet ? Язык Java использует оператор == для сравнения объектов в списке с указанным объектом. Если он находит соответствие, метод возвращает значение true ; в противном случае возвращается false . Поскольку мы сравниваем примитивы, он может найти соответствие, основанное на целочисленных значениях (помните, что оператор == сравнивает примитивы по их значению).

Это хорошо для примитивов, но что если мы хотим сравнить содержимое объектов? Оператор == не сделает это. Для сравнения содержимого объектов мы должны перегрузить метод equals() класса, экземпляром которого является переменная a . Это означает, что нужно создать метод с точно такой же сигнатурой, что и у метода одного из ваших суперклассов, но реализовать метод по другому. Если сделать это, вы сможете сравнивать содержимое двух объектов, а не только проверять, ссылаются ли две переменные на один и тот же экземпляр.


Попробуйте ввести следующий код в метод main() и взгляните на результат, отображаемый в консоли:

Первое сравнение возвращает значение false , поскольку adult1 и adult2 ссылаются на разные экземпляры Adult . Второе сравнение тоже возвращает значение false , поскольку реализация метода equals() по умолчанию просто проверяет, ссылаются ли обе переменные на один и тот же экземпляр. Но поведение equals() по умолчанию обычно не то, что мы хотим. Мы хотели бы сравнивать содержимое двух объектов Adult , чтобы узнать, одинаковые ли они. Для этого мы можем перегрузить equals() . Как видно из двух последних сравнений в приведенном выше примере, класс Integer перегружает метод так, что оператор == возвращает false , но оператор equals() сравнивает на равенство упакованные значения int . Мы сделаем что-то похожее для класса Adult в следующем разделе.

Перегрузка equals()

Перегрузка метода equals() для сравнения объектов на самом деле требует от нас перегрузки двух методов:

Мы перегрузим метод equals() следующим способом, который является обычным стилем в Java:

  • Если объект, который мы собираемся сравнивать, является самим этим объектом, то они очевидно равны, поэтому возвращаем true .
  • Проверяем для уверенности, что объект, который мы собираемся сравнивать, является экземпляром Adult (если нет, два объекта очевидно не одинаковы).
  • Приводим тип входного объекта к Adult , для того чтобы использовать его методы.
  • Сравниваем части двух объектов Adult , которые должны быть равны, для того чтобы два объекта считались «равными» (какое бы определение равенства мы ни использовали).
  • Если какие-либо из этих частей не равны, возвращаем значение false ; в противном случае возвращаем true .

Обратите внимание на то, что мы можем сравнить возраст каждого объекта с помощью == , поскольку это примитивные значения. Для сравнения String мы используем equals() , поскольку этот класс перегружает метод equals() для сравнения содержимого объектов String (если бы мы использовали == , то получали бы false каждый раз, потому что два объекта String никогда не будут одним и тем же объектом). То же самое мы делаем и для ArrayList , поскольку он перегружает equals() для проверки того, что два списка содержат одинаковые элементы в одинаковом порядке. Это хорошо подходит для нашего простого примера.

Когда бы вы ни перегрузили equals() , необходимо также перегрузить hashCode() . Объяснение причины этого выходит за рамки данного руководства, а пока просто знайте, что язык Java использует значение, возвращенное из этого метода, для помещения экземпляров вашего класса в коллекции, которые используют хэш-алгоритм размещения объектов (например HashMap ). Единственными практическими правилами для этого метода (кроме того, что он должен возвращать целое значение) являются два приведенные далее правила. Метод hashCode() должен возвращать:

  • Одно и то же значение для одного и того же объекта постоянно.
  • Одинаковые значения для одинаковых объектов.

Как правило, возврат значений хэш-кода для некоторых или всех переменных экземпляра объекта является достаточно хорошим способом вычисления хэш-кода. Другим вариантом является преобразование переменных в объекты String , объединение их и возврат хэш-кода для полученного объекта String . Еще одним вариантом является умножение одной или нескольких числовых переменных на некоторую константу для дальнейшего обеспечения уникальности, но это часто излишне.

ITnerd

Полезные записки одного нерда

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

Опубликовано Январь 2nd, 2011 Автор: Игорь. В категории Java, Программирование.

Во время программирования на Java одного приложения столкнулся с необходимостью проверить на совпадение две строчки. По привычке сделал стандартную проверку с оператором “==”, вида:

Цукерберг рекомендует:  5 книг по PHP

Какого же было мое удивление, когда проверка не сработала. Я начал копать и разобрался с сутью проблемы, чем сейчас и хочу поделиться.

Все дело в том, что компилятор в указанном выше примере будет проверять не само содержимое строк, а только ссылки на них. Простой пример. Следующий код выведет сообщение “Строки не совпадают“:

String str1 = new String(“test”);
String str2 = new String(“test”);
if (str1 == str2)
System.out.println(“Строчки совпадают”);
else
System.out.println(“Строчки не совпадают”);

Поэтому для сравнения двух строк нужно использовать логический метод equals (object obj). Он вернет значение true , если аргумент obj не равен null, является объектом класса string, и строка, содержащаяся в нем, полностью идентична данной строке вплоть до совпадения регистра букв.

String str1 = “test”;
String str2 = “test”;
if (str1.equals(str2))
System.out.println(“Строчки совпадают”);
else
System.out.println(“Строчки не совпадают”);

Этот код уже верный и возвратит сообщение “Строчки совпадают“.

Кроме того, если вам нужно проверить строки игнорируя регистр – используйте метод equalsIgnoreCase(“obj”). Удачи и будьте аккуратнее при программировании.

2 Комментариев к “Сравнение строк в Java”

Спасибо очень интересная статья.
Только вот вопрос, допустим с if adn equals всё понятно, то как быть кода мы заходим создать цикл,
while и do-while.
О чём в общем то речь, попробую для наглядности привести листинг…
—————–
public class JavaApplication1 <

public static void main(String[] args) <
int x;
int y;
do <
x=Integer.parseInt(JOptionPane.showInputDialog(“Значение х”));
y=Integer.parseInt(JOptionPane.showInputDialog(“Значение y”));
>while(x!=y);

JOptionPane.showMessageDialog(null, “Значение верно. ”);

>
>
Здесь как бы всё понятно, что бы повторился цикл нужно чтобы “XY”

То как быть кода x and y принимают значение String

public class JavaApplication1 <

public static void main(String[] args) <
String x;
String y;
do <
x=JOptionPane.showInputDialog(“Значение х”);
y=JOptionPane.showInputDialog(“Значение y”);
>while(x.equalsIgnoreCase(y));

JOptionPane.showMessageDialog(null, “Значение верно. ”);

>
>
Как видно из листинга, цикл будет бесконечно повторятся, пока значения будут равны…
на примере C# можно решить следующим способом

>
while (x.ToLower()!=y.ToLower())

Вопрос.
Есть ли подобное решение на JAVA .

Как лучше сравнивать перечисляемые типы в Java

Недавно на Stack Overflow я наткнулся на, казалось бы, простой вопрос: “Что лучше использовать для сравнения enum’ов — == или equals() ?”. Вы, конечно, можете сходу ответить, что никакой разницы нет, но будете неправы — в ответах к этому вопросу было приведено много интересных аргументов в пользу обоих вариантов. Я решил, что будет интересно перевести этот спор на русский язык.

Они же оба работают, верно?


Да. Как написано в документации, “допустимо использовать оператор == вместо метода equals , если доподлинно известно, что хотя бы один из них ссылается на перечислимый тип” (“it is permissible to use the == operator in place of the equals method when comparing two object references if it is known that at least one of them refers to an enum constant”). Причина этого очень простая — каждый из объектов enum’а создаётся только единожды, и поэтому, если вы создадите десять переменных равных SomeEnum.RED , они все будут ссылаться на один и тот же объект (а оператор == как раз это и проверяет).

Какие есть преимущества у оператора ==?

  • Он никогда не выбросит NullPointerException :
  • В одном из ответов приводилась цитата Джошуа Блоха (автор книги “Effective Java”; видимо, и цитата оттуда) о том, что этот оператор работает быстрее, и если гарантируется уникальность каждого экземпляра класса, то стоит использовать именно его.
  • Как известно, сравнения через == проверяются на соответствия типов во время компиляции (это хорошо, т.к. поможет вовремя выявить ошибку):
  • Этот вариант короче, и сразу понятно, что происходит именно проверка равенства (т.е. вариант более читаемый).

Ого, как серьёзно все подошли к вопросу! Ну теперь точно буду использовать оператор равенства.

Не спешите так. Не все единогласно за == . Вот что пишут сторонники equals() :

  • Нет ни единого случая, когда переменная перечисляемого типа должна быть равна null — если вы так описываете какое-то особое состояние, то его можно просто заменить на ещё одно допустимое состояние enum’а. А значит, NPE не надо скрывать, так как это, вероятнее всего, ошибка, и чем раньше о ней станет известно, тем лучше.
  • Аргумент про скорость == весьма сомнителен. Современные компиляторы, скорее всего умеют заменять equals на == самостоятельно. Если это не так (как доказали позже, это действительно не так), то это проблема Java, над которой нужно работать.
  • Какой Java-программист не знает, что делает equals ? Такой вариант наоборот более читаем, так как для объектов мы привыкли использовать именно метод equals . Значит, и для enum’ов нужно поступать так же, чтобы не возникало путаницы.

JavaNerd .

В этой статье мы рассмотрим методики сравнения объектов в Java и какие инструменты нам для этого понадобятся. Как вы сможете понять из этой статьи задача сравнения объектов не такая уж, и тривиальная и выработать единый и универсальный подход для сравнения всех объектов едва ли представляется возможным. Сравнение объектов в Java выполняется с помощью оператора сравнения == и метода equals(). Если оператор сравнения можно использовать с примитивами, то метод equals() используется только с экземплярами классов. При их использовании проверяется ссылаются ли переменные на один и тот же объект в памяти. Рассмотрим пример:

Переменная ob1 содержит в себе ссылку на объект класса Object, а переменная ob2 просто ее копирует при объявлении, в итоге две переменных ссылаются на один и тот же объект в памяти, что при сравнении этих двух переменных всегда возвращается true. Другой пример:

Теперь при объявлении каждой из переменных вызывается оператор new, который для каждой из них создает свой экземпляр класса Object, поэтому при сравнении этих двух переменных каждый раз возвращается false, потому что обе переменные указывают на разные объекты в разных участках памяти. Давайте теперь сравним что-то более конкретное, например, две строки:

Как видите поведение метода equals() для класса String несколько отличается. Это происходит по одной простой причине, метод equals() определен в классе Object, поэтому все классы в Java его наследуют и вольны переопределять, что и было сделано в классе String. Как видите методом equals() проверяются на соответствие символы двух строк, если они совпадают, то метод возвращает true. Перед тем как приступить к переопределению метода equals() и комплексному сравнению объектов созданных нами классов, мы рассмотрим инструменты, которые нам для этого понадобятся: оператор instanceof и метод getClass().

Оператор instanceof.

Оператор instanceof служит для проверки к какому классу принадлежит объект. a instanceof B возвращает истину, если в переменной a содержится ссылка на экземпляр класса B, подкласс B (напрямую или косвенно, иначе говоря, состоит в иерархии наследования классов) или реализует интерфейс B (так же напрямую или косвенно). Давайте подробнее рассмотрим, как это работает на примере:

Иерархия классов очень проста, главный класс A, классы B и C от него наследуются. Посмотрим как поведет себя оператор instanceof с нашими классами:

Первая проверка возвращает true, потому что aB является экземпляром класса B. Вторая проверка возвращает true, потому что aB является подклассом A. И последний вызов оператора instanceof возвращает false, несмотря на то, что оба класса B и С наследуются от A, это совершенно разные классы. На самом деле, ситуация с последним вызовом оператора instanceof сложнее, чем может показаться. Типом переменной aB является класс A, иначе говоря, она может содержать в себе любой из трех классов, в том числе класс C и компилятор это проверяет, если возникнет ситуация, при которой оператор instanceof не сможет ни при каких условиях вернуть true – возникнет ошибка компиляции:

Цукерберг рекомендует:  Вакансии UFS.Travel

Переменная с типом класса B на данном этапе нашей иерархии классов ни при каких условиях не может содержать в себе ссылку на класс С, поэтому возникает ошибка компиляции. Опять же, есть один нюанс, это правило не работает для интерфейсов:

Как мы видим связи между классом A и интерфейсом I нет никакой, и тем не менее ошибки компиляции не возникает, а оператор instanceof возвращает false. Всегда существует вероятность в будущем реализации интерфейса тем или иным классом, поэтому в данном случае компилятор идет нам уступки. Если же класс реализует интерфейс, то оператор instanceof вернут true:

Как упоминалось ранее все классы наследуются от класса Object либо напрямую, либо через родительский класс, поэтому a instanceof Object всегда будет возвращать true за исключение одной ситуации:

Так вот, a instanceof Object всегда будет возвращать true, только если a не равна null.

Метод getClass().

Метод getClass() возвращает класс объекта, содержащий сведения об объекте: public final Class getClass(). Как Вы можете заметить метод является конечным и переопределению не подлежит. С методом getClass() все обстоит несколько проще и очевидней нежели с оператором instanceof.

Как видите, метод прост и эффективен, ровно до тех пор, пока не применен механизм наследования. При наследовании этот метод становится менее полезным. Это утверждение может многим показаться спорным, но мы к нему еще вернемся в конце главы, когда будем размышлять о том, каким должен быть идеальный метод для сравнения объектов.

Метод equals().

Почему мы так подробно рассматривали оператор instanceof? Потому что это будет наша первая проверка, хотя многие предпочитают использовать метод getClass(), но обо всем по порядку. Как говорилось выше, метод equals() содержится в классе Object и наследуется всеми классами, в которых мы вправе его переопределить, давайте это сделаем:

В нашем примере метод equals() всегда будет возвращать true, что и было продемонстрировано. Не смотря на то, что в памяти было создано два объекта Eq, метод equals() все равно вернул истину. Единственное на что хотелось бы обратить внимание, это аннотация @Override. Она используется для явного обозначения переопределения метода, если бы мы допустили ошибку и просто перегрузили метод, то с этой аннотацией у нас бы возникла ошибка компиляции:

В примере выше метод equals() перегружен (в качестве параметра методу передается класс Eq вместо Object), что и приводит к ошибке компиляции. Настало время рассмотреть более сложный пример:

В классе Car происходит более комплексная проверка на равенство объектов: первоначально оператор instanceof проверяет, принадлежат ли классы одной иерархии наследования, если нет, то объекты не равны, если принадлежат, то проверка идет по строковому полю name, при совпадении этого поля (ну или при совпадении названия машин) объекты будут равны. Рассмотрим пример сравнения объектов с помощью метода getClass():
Так как метод equals() является одним из ключевых в Java, существует ряд правил касающихся его работы:

  • Рефлексивность. При вызове x.equals(x) по любой ненулевой ссылке x должно возвращаться логическое значение true.
  • Симметричность. При вызове x.equals(y) по любым ссылкам x и y должно возвращаться логическое значение true, тогда и только тогда, когда при вызове y.equals(x) возвращается логическое значение true.
  • Транзитивность. Если при вызовах x.equals(y) и y.equals(z) по любым ссылкам x, y и z возвращается логическое значение true, то и при вызове x.equls(z) возвращается логическое значение true.
  • Согласованность. Если объекты, на которые делаются ссылки x и y, не изменяются, то при повторном вызове x.equals(y) должно возвращаться тоже самое значение.
    При вызове x.equals(null) по любой непустой ссылке x, должно возвращаться логическое значение false.

Метод hashCode()

Хэш-код — это целое число, генерируемое на основе конкретного объекта. Метод hashCode() тесно взаимосвязан с методом equals() (если x и y – разные объекты, то с высокой долей вероятности должны различаться результаты вызовов hashCode() для этих объектов), поэтому Oracle рекомендует при переопределении метода equals() так же переопределять метод hashCode():

Как правильно сравнивать строки в Java?​

Так как оператор «==» сравнивает на идентичность только примитивы и ссылки на объект, в java для сравнения строк используется метод equals(), наследуемый от класса Object и реализованный в классе java.lang.String. Метод сравнивает строку, на которой он вызван, со строкой, которую в него передали и возвращает true или false.

Выводом вышеуказанного кода будет сначала false, затем true.

Комментарии:

Как правильно сравнивать строки в Java?​: 3 комментария

Любопытно, что если создавать строки не через new, а просто присвоить им одинаковые значения, то они будут ссылаться на один объект
String str1 = «myString»;
String str2 = «myString»; System.out.println(str1==str2);
результат будет true. Не знаю зачем так, но все таки) Мб кто объяснит… Банальная экономия памяти может?

Всё верно. Ведь в Java строки, в зависимости от способа их создания, могут помещаться в пул или просто сваливаться в кучу. При создании используя кавычки, строки помещаются в пул и перед созданием проверяется, не было ли ранее такой строки уже в нём? Если она там есть, то просто возвращается ссылка на неё. От сюда мы получаем ссылки на один и тот же объект. И да, это экономия памяти. Стоит помнить, что строки в Java финализированы, а это значит что ссылка на один объект строки из разных мест нам ничем не грозит.
String s1 = «hello»;
String s2 = «hello»;
System.out.println(s1==s2);
s1+=», friend!»;
System.out.println(s1==s2);
System.out.println(«s1: » + s1);
System.out.println(«s2: » + s2);
Вывод:
true
false
s1: hello, friend!
s2: hello

То есть при любом изменении создается новая строка, как я понял, а старая висит в памяти пока ее мусорщик не почистит? Хреновато, когда у тебя цикл на over9000 итераций, в котором строками манипулируют

java — Java Сравнение слов

Раньше у меня была проблема с array out of bounds , но я этого больше не получаю.

Моя проблема заключается в использовании моего ArrayList , он будет распечатываться:

Оставляя task и run .

Я смотрел на это некоторое время, и я не могу понять это. Любая помощь будет замечательной!

Я не получаю массив за пределами кода, который у меня есть, у меня проблемы с распечаткой полного списка. Я получаю какое-то время, когда aba запускает школьную задачу abaa tasker, поручая abaxaa бегун бегунов, участвующих в школьных школах, но затем, когда я печатаю его, aba aba abaa abaxaa бегун бегунов школьников школьных школьных школьников. Таким образом, мне не хватает задачи и

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих