В чем разница между “.equals” и “==”?[дубликат]
https://stackoverflow.com/questions/1643067
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
На этот вопрос уже есть ответ здесь:
Сегодня я сменил лектора, и он заявил мне, что использует странный код.(Он сказал, что лучше использовать .equals и когда я спросил почему, он ответил "потому что это так!")
Итак, вот пример:
if (o1.equals(o2))
{
System.out.println("Both integer objects are the same");
}
Вместо того, к чему я привык:
if (o1 == o2)
{
System.out.println("Both integer objects are the same");
}
В чем разница между этими двумя.И почему его способ (используя .equals) лучше?
Нашел это при быстром поиске, но я действительно не могу понять смысла этого ответа:
Решение
На языке Java, == всегда просто сравнивает две ссылки (то есть для не примитивов) - т. е.он проверяет, ссылаются ли два операнда на один и тот же объект.
Однако, в equals метод может быть переопределен - таким образом, два различных объекта все еще могут быть равны.
Например:
String x = "hello";
String y = new String(new char[] { 'h', 'e', 'l', 'l', 'o' });
System.out.println(x == y); // false
System.out.println(x.equals(y)); // true
Кроме того, стоит знать, что любые два равных строковые константы (в основном строковые литералы, но также комбинации строковых констант посредством конкатенации) в конечном итоге будут ссылаться на одну и ту же строку.Например:
String x = "hello";
String y = "he" + "llo";
System.out.println(x == y); // true!
Здесь x и y являются ссылками на одну и ту же строку, потому что y равна ли константа времени компиляции "hello".
Другие советы
Оператор == сравнивает, являются ли объекты одинаковыми экземпляр.Оператор equals() сравнивает состояние объектов (например,если все атрибуты равны).Вы даже можете переопределить метод equals(), чтобы самостоятельно определять, когда один объект равен другому.
Если каждый из нас с вами зайдет в банк, каждый откроет совершенно новый счет и каждый внесет по 100 долларов, тогда...
myAccount.equals(yourAccount)являетсяtrueпотому что у них есть то же значение, ноmyAccount == yourAccountявляетсяfalseпотому что они не являются тот же аккаунт.
(Предполагая соответствующие определения Account класс, конечно.;-)
== - это оператор.equals - это метод , определенный в классе Object
== проверяет, имеют ли два объекта одинаковый адрес в памяти, и для примитива проверяет, имеют ли они одинаковое значение.метод equals, с другой стороны, проверяет, имеют ли два сравниваемых объекта одинаковое значение (в зависимости от того, как, конечно, метод equals был реализован для объектов.метод equals не может быть применен к примитивам (что означает, что если a является примитивом a.equals(someobject) не допускается, однако someobject.equals(a) разрешен).
== оператор сравнивает две ссылки на объекты, чтобы проверить, ссылаются ли они на один и тот же экземпляр.Это также вернет true при успешном совпадении.например
public class Example{
public static void main(String[] args){
String s1 = "Java";
String s2 = "Java";
String s3 = new string ("Java");
test(Sl == s2) //true
test(s1 == s3) //false
}}
приведенный выше пример == является эталонным сравнением, т. е.оба объекта указывают на одну и ту же ячейку памяти
String equals() вычисляется для сравнения значений в объектах.
public class EqualsExample1{
public static void main(String args[]){
String s = "Hell";
String s1 =new string( "Hello");
String s2 =new string( "Hello");
s1.equals(s2); //true
s.equals(s1) ; //false
}}
приведенный выше пример Сравнивает содержимое строк.Он вернет true, если строка совпадает, в противном случае возвращает false .
В Java, когда “==” оператор используется для сравнения 2 объектов, он проверяет, ссылаются ли объекты на одно и то же место в памяти.БЫВШИЙ:
String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1 == obj2)
System.out.println("obj1==obj2 is TRUE");
else
System.out.println("obj1==obj2 is FALSE");
Даже если строки содержат одинаковые символы (“xyz”), приведенный выше код фактически выведет:obj1==obj2 равно FALSE
Java String класс фактически переопределяет значение по умолчанию равно() реализация в классе Object – и она переопределяет метод, так что он проверяет только значения строк, а не их расположение в памяти.Это означает, что если вы вызываете метод equals() для сравнения 2-х строковых объектов, то до тех пор, пока фактическая последовательность символов равна, оба объекта считаются равными.
String obj1 = new String("xyz");
String obj2 = new String("xyz");
if(obj1.equals(obj2))
System.out.printlln("obj1==obj2 is TRUE");
else
System.out.println("obj1==obj2 is FALSE");
Этот код выведет следующее:
obj1==obj2 является ИСТИННЫМ
public static void main(String[] args){
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2));
////
System.out.println(s1 == s2);
System.out.println("-----------------------------");
String s3 = "hello";
String s4 = "hello";
System.out.println(s3.equals(s4));
////
System.out.println(s3 == s4);
}
Здесь, в этом коде, вы можете сопоставить оба '==' и '.equals'
здесь .equals используется для сравнения ссылочных объектов, а '==' используется для сравнения состояния объектов..
(1) == может быть применен как к примитивам, так и к типам объектов, но метод equals() может быть применен только к типам объектов.
(2) == не может быть переопределен для сравнения содержимого, но метод equals может быть переопределен для сравнения содержимого (например;Класс String, классы-оболочки, классы коллекции).
(3) == выдает ошибку несравнимых типов при попытке применить для разнородных типов , где метод as equals возвращает false.
В equals( ) метод и == оператор выполняет две разные операции.В equals( ) метод сравнивает символы внутри String объект.В == оператор сравнивает две ссылки на объекты, чтобы увидеть, ссылаются ли они на один и тот же экземпляр.Следующая программа показывает, как два разных строковых объекта могут содержать одинаковые символы, но ссылки на эти объекты не будут сравниваться как равные:
// equals() vs ==
class EqualsNotEqualTo {
public static void main(String args[]) {
String s1 = "Hello";
String s2 = new String(s1);
System.out.println(s1 + " equals " + s2 + " -> " +
s1.equals(s2));
System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));
}
}
Переменная s1 ссылается на экземпляр String , созданный “Hello”.Объект , на который ссылается
s2 создается с помощью s1 в качестве инициализатора.Таким образом, содержимое двух строковых объектов идентично,
но это разные объекты.Это означает , что s1 и s2 не относятся к одним и тем же объектам и
следовательно, не ==, как показано здесь на выходе из предыдущего примера:
Hello equals Hello -> true
Hello == Hello -> false
Допустим, что оператор "==" возвращает true, если оба операнда принадлежат одному и тому же объекту, но когда он вернет true, поскольку мы не можем присвоить одному объекту несколько значений
public static void main(String [] args){
String s1 = "Hello";
String s1 = "Hello"; // This is not possible to assign multiple values to single object
if(s1 == s1){
// Now this retruns true
}
}
Теперь, когда это происходит, практически говоря, если этого не происходит, то почему это == сравнивает функциональность....
Вот простая интерпретация вашей проблемы:
== (равно) используется для вычисления арифметического выражения
где как
метод equals(), используемый для сравнения строки
Следовательно, лучше использовать == для числовых операций и метод equals() для операций, связанных со строками.Таким образом, для сравнения объектов метод equals() был бы правильным выбором.
