Какая разница между ".equals" и "=="?

Сегодня я переключил преподавателей, и он сказал, используя мне странный код. (Он сказал, что лучше использовать .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) лучше?

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

ОТВЕТЫ

Ответ 1

В 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".

Ответ 2

Оператор == сравнивает, если объекты являются тем же самым экземпляром. Оператор equals() сравнивает состояние объектов (например, если все атрибуты равны). Вы можете даже переопределить метод equals(), чтобы определить себя, когда объект равен другому.

Ответ 3

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

  • myAccount.equals(yourAccount) true, поскольку они имеют одно значение, но
  • myAccount == yourAccount - это false, потому что они не являются той же учетной записью.

(Предполагая соответствующие определения класса Account, конечно.; -)

Ответ 4

== - оператор. equals - это метод, определенный в классе Object

== проверяет, имеют ли два объекта один и тот же адрес в памяти, а для примитива он проверяет, имеет ли он тот же метод value.equals, с другой стороны, проверяет, имеют ли два объекта, которые сравниваются, равное значение (в зависимости от как, к примеру, метод equals реализован для объектов. Метод equals не может применяться к примитивам (что означает, что если a является примитивным a.equals(некоторый объект) не допускается, однако некоторый объект допускает равенство (a)).

Ответ 5

Оператор

== сравнивает две ссылки на объекты, чтобы проверить, относятся ли они к одному экземпляру. Это также вернет 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, если строковые совпадения, else возвращает false.

Ответ 6

В Java, когда оператор "==" используется для сравнения двух объектов, он проверяет, ссылаются ли объекты на одно и то же место в памяти. EX:

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 фактически переопределяет реализацию по умолчанию equals() в классе Object - и переопределяет метод, чтобы он проверял только значения строк, а не их местоположения в памяти. Это означает, что если вы вызываете метод equals() для сравнения двух объектов String, то, пока действительная последовательность символов равна, оба объекта считаются равными.

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 имеет значение TRUE

Ответ 7

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 используется для сравнения ссылочных объектов, а '==' используется для сравнения состояния объектов.

Ответ 8

(1) == может применяться как для примитивов, так и для типов объектов, но метод equals() может применяться только для типов объектов.

(2) == не может быть переопределен для сравнения содержимого, но метод equals может быть переопределен для сравнения содержимого (например, класс String, классы-оболочки, классы коллекции).

(3) == дает несравненную ошибку типов при попытке применить для гетерогенных типов, когда метод equals возвращает false.

Ответ 9

Метод equals( ) и оператор == выполняют две разные операции. Метод equals( ) сравнивает символы внутри объекта String. Оператор == сравнивает две ссылки на объекты, чтобы увидеть, относятся ли они к одному экземпляру. Следующая программа показывает, как два разных объекта 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 в качестве инициализатора. Таким образом, содержимое двух объектов String идентично, но они - разные объекты. Это означает, что s1 и s2 не относятся к тем же объектам и следовательно, не ==, как показано здесь на выходе предыдущего примера:

Hello equals Hello -> true
Hello == Hello -> false

Ответ 10

Давайте скажем, что оператор "==" возвращает 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
   }
}

Теперь, когда это происходит практически, если это не так, то почему это == сравнивает функциональность....

Ответ 11

Вот простая интерпретация вашей проблемы:

== (равно), используемый для оценки арифметического выражения

где as

Метод equals(), используемый для сравнения строки

Поэтому лучше использовать == для числовых операций и метод equals() для операций, связанных со строками. Таким образом, для сравнения объектов метод equals() был бы правильным выбором.