В чем разница между == vs equals() в Java?

Источник

user2530951 17 июн '21 в 14:53

Основное различие между == и equals()

1) == используется для сравнения примитивов.

Например:

        String string1 = "Ravi";
        String string2 = "Ravi";
        String string3 = new String("Ravi");
        String string4 = new String("Prakash");

        System.out.println(string1 == string2); // true because same reference in string pool
        System.out.println(string1 == string3); // false

2) equals() используется для сравнения объектов. Например:

        System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects
        System.out.println(string1.equals(string3)); // true
        System.out.println(string1.equals(string4)); // false

Источник

user8630563 23 сен '17 в 07:08

"==" фактически сравнивают две ссылки на объекты, чтобы увидеть, указывают ли они на один и тот же объект.

"равно", что является "глубоким сравнением", которое сравнивает фактические строковые значения.

Источник

user6230028 02 окт '17 в 18:05

Когда вы оцениваете код, становится очень ясно, что (==) сравнивает в соответствии с адресом памяти, а equals(Object o) сравнивает hashCode() экземпляров. Вот почему сказано, что не нарушайте контракт между equals() и hashCode(), если вы не столкнетесь с неожиданностями позже.

    String s1 = new String("Ali");
    String s2 = new String("Veli");
    String s3 = new String("Ali");

    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
    System.out.println(s3.hashCode());


    System.out.println("(s1==s2):" + (s1 == s2));
    System.out.println("(s1==s3):" + (s1 == s3));


    System.out.println("s1.equals(s2):" + (s1.equals(s2)));
    System.out.println("s1.equal(s3):" + (s1.equals(s3)));


    /*Output 
    96670     
    3615852
    96670
    (s1==s2):false
    (s1==s3):false
    s1.equals(s2):false
    s1.equal(s3):true
    */

Источник

user4253424 22 июл '17 в 13:31

Оператор ==:

== - это реляционный оператор в Java, который используется для сравнения двух операндов. Он используется для определения, равны ли два операнда или нет. Используя оператор ==, вы можете сравнить любой тип примитива, такой как int, char, float и Booleans. После сравнения оператор == возвращает логическое значение. Если два операнда равны, оператор == возвращает истинное значение. Однако, если два операнда не равны, он возвращает ложное значение. При использовании с объектами оператор == сравнивает две ссылки на объекты и определяет, ссылаются ли они на один и тот же экземпляр.

Метод.equals()

equals () - это метод, доступный в классе String, который используется для сравнения двух строк и определения, равны ли они. Этот метод возвращает логическое значение в результате сравнения. Если две строки содержат одинаковые символы в одинаковом порядке, метод equals () возвращает true. В противном случае он возвращает ложное значение.

Например:

http://goo.gl/Sa3q5Y

Источник

user1622201 29 сен '15 в 03:54

Оператор == всегда сравнивается. Но в случае

метод equals()

это зависит от реализации, если мы переопределяем метод equals, чем он сравнивает объект с базовой реализацией, указанной в переопределенном методе.

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//fasle
      obj==obj1 // fasle
    }
 }

в вышеприведенном коде и объект obj, и объект obj1 содержат одинаковые данные, но ссылка на них не одинакова, поэтому равно false и ==. но если мы переопределим метод равно

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }
    public boolean equals(Object obj)
    {
       A a1=(A)obj;
      return this.id==a1.id;
    }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//true
      obj==obj1 // fasle
    }
 }

знать, проверить это вернет true и false для того же случая, только мы переопределены

метод равных.

он сравнивает объект по основному содержанию (id) объекта

но ==

еще сравните ссылки на объект.

3

Источник

user5746371 03 фев '16 в 17:48

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

А также == на самом деле смотрит на значения для примитивных типов, для объектов он проверяет ссылку.

3

Источник

user4517706 24 мар '15 в 06:15

== может использоваться во многих типах объектов, но вы можете использовать Object.equals для любого типа, особенно для строк и маркеров карты Google.

Источник

user1664424 15 дек '14 в 06:05

public class StringPool {

public static void main(String[] args) {

    String s1 = "Cat";// will create reference in string pool of heap memory
    String s2 = "Cat";
    String s3 = new String("Cat");//will create a object in heap memory

    // Using == will give us true because same reference in string pool

    if (s1 == s2) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using == with reference and Object will give us False

    if (s1 == s3) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using .equals method which refers to value

    if (s1.equals(s3)) {
        System.out.println("true");
    } else {
        System.out.println("False");
    }

    }
  }

---- вывод ----- правда ложь правда

Источник

user6064025 19 ноя '16 в 09:10

Поскольку Java не поддерживает перегрузку операторов, == ведет себя одинаково для каждого объекта, но метод equals() является методом, который может быть переопределен в Java, а логика сравнения объектов может быть изменена на основе бизнес-правил.

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

Сравнение строк - это распространенный сценарий использования метода == и equals. Поскольку переопределение класса java.lang.String равно методу, он возвращает true, если два объекта String содержат одинаковое содержимое, но == будет возвращать true, только если две ссылки указывают на один и тот же объект.

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

public class TEstT{

    public static void main(String[] args) {

String text1 = new String("apple");
String text2 = new String("apple");

//since two strings are different object result should be false
boolean result = text1 == text2;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = text1.equals(text2);
System.out.println("Comparing two Strings with same content using equals method: " + result);

text2 = text1;
//since both text2 and text1d reference variable are pointing to same object
//"==" should return true
result = (text1 == text2);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

}
}

Источник

user4261022 02 фев '15 в 12:03

Возможно, стоит добавить, что для объектов-оболочек для примитивных типов - то есть Int, Long, Double - == вернет true, если два значения равны.

Long a = 10L;
Long b = 10L;

if (a == b) {
    System.out.println("Wrapped primitives behave like values");
}

В отличие от этого, если поместить вышеупомянутые два Long в два отдельных ArrayLists, equals видит их как одинаковые, а == - нет.

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> d = new ArrayList<>();

c.add(a);
d.add(b);
if (c == d) System.out.println("No way!");
if (c.equals(d)) System.out.println("Yes, this is true.");

Источник

user2102730 12 дек '14 в 18:44

Это разница между идентичностью и эквивалентностью.

a == bозначает, что a и b идентичны, то есть они являются символами одного и того же объекта в памяти.

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

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

1

Источник

user2029217 14 июн '20 в 18:14

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

1

Источник

user10548773 24 окт '18 в 15:12

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

Это может дать вам большую производительность (?) За счет большей сложности.

Например:

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

Сложность компромисса: следующие могут вас удивить:

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

Я советую вам держаться подальше от такой микрооптимизации и всегда использовать .equals для объектов, и == для примитивов:

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);

1

Источник

user895245 14 фев '16 в 23:35

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

equals() это метод, унаследованный от Object учебный класс. Этот метод по умолчанию сравнивает, если два объекта имеют одну и ту же ссылку. Это значит:

object1.equals(object2) <=> object1 == object2

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

Воплощать в жизнь hashCode() при установлении равенства является частью Java Object Contract. Если вы работаете с коллекциями, и вы не реализовали hashCode() Могут случиться странные плохие вещи:

HashMap<Cat, String> cats = new HashMap<>();
Cat cat = new Cat("molly");
cats.put(cat, "This is a cool cat");
System.out.println(cats.get(new Cat("molly"));

null будет напечатан после выполнения предыдущего кода, если вы не реализовали hashCode(),

Источник

user3705840 26 апр '16 в 21:20

В общем, оба оператора equals() и "==" в Java используются для сравнения объектов с целью проверки равенства, но вот некоторые из различий между ними:

Основное различие между методом.equals() и оператором == заключается в том, что один является методом, а другой - оператором.

Мы можем использовать операторы == для сравнения ссылок (сравнение адресов) и метод.equals() для сравнения содержимого. Проще говоря, == проверяет, указывают ли оба объекта на одно и то же место в памяти, тогда как.equals() оценивает сравнение значений в объектах. Если класс не переопределяет метод equals, то по умолчанию он использует метод equals(Object o) ближайшего родительского класса, который переопределил этот метод. Смотрите это для деталей

Источник

user4067548 13 янв '18 в 05:01

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

Источник

user9575631 07 июн '21 в 19:58

Метод equals() в основном сравнивает исходное содержимое объекта.

Если мы напишем

          String s1 = "Samim";
    String s2 = "Samim";
    String s3 = new String("Samim");
    String s4 = new String("Samim");

    System.out.println(s1.equals(s2));
    System.out.println(s2.equals(s3));
    System.out.println(s3.equals(s4));

Результат будет

      true 
true 
true

Поскольку метод equals() сравнивает содержимое объекта. в первом System.out.println() содержимое s1 и s2 одинаково, поэтому оно печатает true. И то же самое для других двух System.out.println() верно.

Опять таки ,

          String s1 = "Samim";
    String s2 = "Samim";
    String s3 = new String("Samim");
    String s4 = new String("Samim");
    
    System.out.println(s1 == s2);
    System.out.println(s2 == s3);
    System.out.println(s3 == s4);

Результат будет

      true
false 
false

Потому что оператор == в основном сравнивает ссылки на объект, а не значение. В первом System.out.println() ссылки s1 и s2 одинаковы, поэтому он возвращает true.

Во втором System.out.println() создается объект s3, поэтому будет создана другая ссылка s3, а ссылки s2 и s3 будут отличаться, по этой причине он возвращает «false».

Третий System.out.println(), следуйте правилам второго System.out.println(), поэтому он вернет «false».