Я хотел уточнить, правильно ли я это понимаю:
==
является эталонным сравнением, т.е. оба объекта указывают на одну и ту же ячейку памяти.equals()
оценивает сравнение значений в объектах
java
identity
equality
object-comparison
brainydexter
источник
источник
.equals()
как о значительном эквивалентеОтветы:
В общем, ответ на ваш вопрос "да", но ...
.equals(...)
будет сравнивать только то, что написано для сравнения, не больше, не меньше.equals(Object o)
метод ближайшего родительского класса, который переопределил этот метод.Object#equals(Object o)
метод. В соответствии с Object API это так же, как==
; то есть он возвращает true тогда и только тогда, когда обе переменные ссылаются на один и тот же объект, если их ссылки одинаковы. Таким образом, вы будете тестировать на предметное равенство, а не функциональное равенство .hashCode
если переопределите,equals
чтобы не «нарушить контракт». Согласно API, результат, возвращаемыйhashCode()
методом для двух объектов, должен быть одинаковым, если ихequals
методы показывают, что они эквивалентны. Обратное утверждение не обязательно верно.источник
==
проверяет ссылку на память, то почему я получаю это странное поведение в [this] [1] [1]: docs.google.com/document/d/… Я ожидал, что вывод будет истинным. могу очистить мои заблужденияThe equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
<br/>Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
( docs.oracle.com/javase/7/docs/api/java/lang/… )По отношению к классу String:
В равно () метод сравнивает «значение» внутри экземпляров String (в куче) независимо от того, если две ссылки на объекты относятся к той же строки , например , или нет. Если любые две ссылки на объекты типа String ссылаются на один и тот же экземпляр String, тогда отлично! Если две ссылки на объекты ссылаются на два разных экземпляра String .. это не имеет значения. Это «значение» (то есть содержимое массива символов) внутри каждого сравниваемого экземпляра String.
С другой стороны, оператор "==" сравнивает значение двух ссылок на объекты, чтобы определить, ссылаются ли они на один и тот же экземпляр String . Если значение обеих ссылок на объекты «ссылается» на один и тот же экземпляр String, то результатом логического выражения будет «true» .. duh. Если, с другой стороны, значения обеих ссылок на объекты "ссылаются" на разные экземпляры String (даже если оба экземпляра String имеют одинаковые "значения", то есть содержимое символьных массивов каждого экземпляра String одинаково), Результатом логического выражения будет «ложь».
Как с любым объяснением, позвольте этому погрузиться.
Надеюсь, это немного прояснит ситуацию.
источник
String
х,==
это референс равна а, да, но это , как правило , работает (как и в двухString
с с тем же содержанием , будет , как правило , быть==
друг с другом), из - за того , как Java ручкиString
s. Это не всегда, и это, безусловно, плохая практика, но это распространенная ошибка, особенно для людей с других языков.String
строить из строкового литерала будет добавлен к чему - то называетсяString constant pool
, например ,String s1 = "someString"; String s2 = "someString;"
какs1
иs2
разделит ту же ссылку.s1 == s2
вернет истину. Но если они были созданы с помощьюString constructor
, например,String s1 = new String("someString"); String s2 = new String("someString");
тогда они не будут использовать одну и ту же ссылку.s1 == s2
вернет ложь.Существуют небольшие различия в зависимости от того, говорите ли вы о «примитивах» или «типах объектов»; то же самое можно сказать, если вы говорите о «статических» или «нестатических» членах; Вы также можете смешать все вышеперечисленное ...
Вот пример (вы можете запустить его):
Вы можете сравнить объяснения для "==" (Оператор равенства) и ".equals (...)" (метод в классе java.lang.Object) по следующим ссылкам:
источник
Разница между == и equals смутила меня некоторое время, пока я не решил поближе взглянуть на это. Многие из них говорят, что для сравнения строк следует использовать
equals
а не==
. Надеюсь, в этом ответе я смогу сказать разницу.Лучший способ ответить на этот вопрос - задать себе несколько вопросов. Итак, начнем:
Какой вывод для следующей программы:
если вы говорите,
Я скажу, что вы правы, но почему вы это сказали ? и если вы говорите, выход
Я скажу, что вы не правы, но я все равно буду спрашивать вас, почему вы думаете, что это правильно?
Хорошо, давайте попробуем ответить на этот вопрос:
Какой вывод для следующей программы:
Теперь, если вы говорите,
Я скажу, что вы не правы, но почему это не так сейчас ? правильный вывод для этой программы
Пожалуйста, сравните вышеуказанную программу и попробуйте подумать об этом.
Хорошо. Теперь это может помочь (пожалуйста, прочитайте это: напечатать адрес объекта - невозможно, но все же мы можем его использовать.)
Можете ли вы просто подумать о выводе последних трех строк в коде выше: для меня ideone распечатал это ( вы можете проверить код здесь ):
Ой! Теперь вы видите, что identityHashCode (mango) равен identityHashCode (mango2), но не равен identityHashCode (mango3)
Несмотря на то, что все строковые переменные - mango, mango2 и mango3 - имеют одинаковое значение, то есть «манго», они
identityHashCode()
все же не одинаковы для всех.Теперь попробуйте раскомментировать эту строку
// mango2 = "mang";
и запустите ее снова, на этот раз вы увидите, что все триidentityHashCode()
разные. Хм, это полезный советмы знаем, что если
hashcode(x)=N
иhashcode(y)=N
=>x is equal to y
Я не уверен, как Java работает внутри, но я предполагаю, что это то, что произошло, когда я сказал:
Java создал строку,
"mango"
которая была указана (на которую ссылается) переменнаяmango
что-то вроде этогоТеперь в следующей строке, когда я сказал:
Он фактически использовал ту же строку,
"mango"
которая выглядит примерно такИ манго, и манго2 указывают на одну и ту же ссылку. Теперь, когда я сказал
Он фактически создал совершенно новую ссылку (строку) для «манго». который выглядит примерно так,
и именно поэтому, когда я выставляю значения для
mango == mango2
, он выставляетtrue
. и когда я выставляю значение дляmango3 == mango2
, оно выводитсяfalse
(даже когда значения были одинаковыми).и когда вы раскомментировали строку,
// mango2 = "mang";
она фактически создала строку «mang», которая превратила наш график следующим образом:Вот почему identityHashCode не одинаков для всех.
Надеюсь, это поможет вам, ребята. На самом деле, я хотел сгенерировать тестовый пример, где == не выполняется и равно () пройти. Пожалуйста, не стесняйтесь комментировать и дайте мне знать, если я не прав.
источник
mango == mango2
это потому, что вы не создалиmango2
новый объект String, а вместо этого просто указали ссылку"mango"
?Ура :-)
источник
Вам придется переопределить функцию equals (вместе с другими), чтобы использовать ее с пользовательскими классами.
Метод equals сравнивает объекты.
==
Бинарный оператор сравнивает адрес памяти.источник
И ==, и .equals () ссылаются на один и тот же объект, если вы не переопределяете .equals ().
Это ваше желание, что вы хотите сделать, как только вы переопределите .equals (). Вы можете сравнить состояние вызывающего объекта с переданным состоянием объекта или просто вызвать super.equals ()
источник
==
является оператором иequals()
является методом .Операторы обычно используются для сравнения примитивных типов и, следовательно
==
, используются для сравнения адресов памяти, аequals()
метод используется для сравнения объектов .источник
источник
Просто помните, что
.equals(...)
это должно быть реализовано тем классом, который вы пытаетесь сравнить. В противном случае, нет особого смысла; версия метода для класса Object делает то же самое, что и операция сравнения: Object # equals .Единственный раз, когда вы действительно хотите использовать оператор сравнения для объектов, это когда вы сравниваете Enums. Это связано с тем, что одновременно существует только один экземпляр значения Enum. Например, учитывая перечисление
У вас никогда не будет более одного экземпляра за
A
раз, и то же самое дляB
иC
. Это означает, что вы можете написать такой метод:И у вас не будет проблем вообще.
источник
Когда вы оцениваете код, становится очень ясно, что (==) сравнивает в соответствии с адресом памяти, а equals (Object o) сравнивает hashCode () экземпляров. Вот почему сказано, что не нарушайте контракт между equals () и hashCode (), если вы не столкнетесь с неожиданностями позже.
источник
Вот общее правило для разницы между
relational operator ==
иthe method .equals()
.object1 == object2
сравнивает, ссылаются ли объекты, на которые ссылаются object1 и object2, на одну и ту же ячейку памяти в куче .object1.equals(object2)
сравнивает значения object1 и object2 независимо от того, где они находятся в памяти .Это можно хорошо продемонстрировать с помощью String
Сценарий 1
Сценарий 2
Это сравнение строк может быть использовано в качестве основы для сравнения других типов объектов.
Например, если у меня есть класс Person , мне нужно определить базу критериев, по которой я буду сравнивать двух людей . Допустим, у этого класса есть переменные экземпляра роста и веса.
Таким образом, создавая объекты-личности
person1 and person2
и сравнивая их с помощью.equals()
I, мне нужно переопределить метод equals класса person, чтобы определить, на основании каких переменных экземпляра (высоты или веса) будет выполняться сравнение.Однако
== operator will still return results based on the memory location of the two objects(person1 and person2)
.Для простоты обобщения этого объекта сравнения я создал следующий тестовый класс. Экспериментируя с этими концепциями, вы обнаружите множество фактов .
Результат выполнения этого класса:
источник
Также обратите внимание, что
.equals()
обычно содержит==
для тестирования, так как это первое, что вы хотели бы проверить, если вы хотите проверить, если два объекта равны.И на
==
самом деле смотрит на значения для примитивных типов, для объектов он проверяет ссылку.источник
Оператор == всегда сравнивается. Но в случае
это зависит от реализации, если мы переопределяем метод equals, чем он сравнивает объект с базовой реализацией, указанной в переопределенном методе.
в приведенном выше коде и объект obj, и объект obj1 содержат одни и те же данные, но ссылка на них не одинакова, поэтому равно return false и == также. но если мы переопределить метод равно, чем
знать, проверить это вернет истину и ложь для того же случая, только мы переопределены
он сравнивает объект на основе содержимого (id) объекта
еще сравните ссылки на объект.
источник
Основное различие между == и equals ()
1) == используется для сравнения примитивов.
Например :
2) equals () используется для сравнения объектов. Например :
источник
==
может использоваться во многих типах объектов, но вы можете использоватьObject.equals
для любого типа, особенно для строк и маркеров карты Google.источник
---- вывод ----- правда ложь правда
источник
Возможно, стоит добавить, что для объектов-оболочек для примитивных типов - то есть Int, Long, Double - == вернет true, если два значения равны.
В отличие от этого, если поместить вышеупомянутые два Long в два отдельных ArrayLists, equals видит их одинаковыми, но == - нет.
источник
Long a = 128l; Long b = 128l; System.out.println(a == b);
Строка бассейн (ака интернирование ) и Integer бассейн размытие разница дальше, и может позволить вам использовать
==
для объектов , в некоторых случаях вместо.equals
Это может дать вам большую производительность (?) За счет большей сложности.
Например:
Сложность компромисса: следующие могут вас удивить:
Я советую вам держаться подальше от такой микрооптимизации и всегда использовать
.equals
для объектов и==
для примитивов:источник
Короче говоря, ответ «да».
В Java
==
оператор сравнивает два объекта, чтобы увидеть, указывают ли они на одну и ту же область памяти; в то время как.equals()
метод фактически сравнивает два объекта, чтобы увидеть, имеют ли они одинаковое значение объекта.источник
В принципе,
==
сравнивается, если два объекта имеют одну и ту же ссылку в куче, поэтому, если две ссылки не связаны с одним и тем же объектом, это сравнение будет ложным.equals()
это метод, унаследованный отObject
класса. Этот метод по умолчанию сравнивает, если два объекта имеют одну и ту же ссылку. Это значит:object1.equals(object2)
<=>object1 == object2
Однако, если вы хотите установить равенство между двумя объектами одного класса, вы должны переопределить этот метод. Также очень важно переопределить метод,
hashCode()
если вы переопределилиequals()
.Реализация
hashCode()
при установлении равенства является частью Java Object Contract. Если вы работаете с коллекциями, но не реализовалиhashCode()
, могут произойти странные плохие вещи:null
будет напечатан после выполнения предыдущего кода, если вы не реализовалиhashCode()
.источник
Поскольку Java не поддерживает перегрузку операторов, == ведет себя одинаково для каждого объекта, но метод equals () является методом, который может быть переопределен в Java, а логика сравнения объектов может быть изменена на основе бизнес-правил.
Основное различие между == и equals в Java заключается в том, что «==» используется для сравнения примитивов, а метод equals () рекомендуется для проверки равенства объектов.
Сравнение строк - это распространенный сценарий использования метода == и equals. Поскольку переопределение класса java.lang.String равно методу, он возвращает true, если два объекта String содержат одинаковое содержимое, но == будет возвращать true, только если две ссылки указывают на один и тот же объект.
Вот пример сравнения двух строк в Java на равенство с использованием метода == и equals (), который устранит некоторые сомнения:
источник