Заголовок Java getHeaderFields не равен его значению [duplicate]

Оператор == проверяет, имеют ли две переменные одинаковые ссылки (aka указатель на адрес памяти).

String foo = new String("abc");
String bar = new String("abc");

if(foo==bar)
// False (The objects are not the same)

bar = foo;

if(foo==bar)
// True (Now the objects are the same)

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

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

Приветствия: -)

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

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

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

Чтобы контрастировать, выше двух Longs на два отдельных 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.");

Просто помните, что .equals(...) должен быть реализован классом, который вы пытаетесь сравнить. В противном случае, не так много смысла; версия метода для класса Object выполняет то же самое, что и операция сравнения: Объект # равно .

Единственный раз, когда вы действительно хотите использовать оператор сравнения для объектов, является Вы сравниваете Enums. Это происходит потому, что за один раз имеется только один экземпляр значения Enum. Например, с учетом перечисления

enum FooEnum {A, B, C}

У вас никогда не будет более одного экземпляра A за один раз, и то же самое для B и C. Это означает, что вы можете написать такой метод:

public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}

И у вас не будет никаких проблем.

Когда вы оцениваете код, очень ясно, что (==) сравнивается в соответствии с адресом памяти, а 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
    */

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

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

Разница между == и equа меня немного смутила, пока я не решил поближе рассмотреть ее. Многие из них говорят, что для сравнения строки вы должны использовать equals, а не ==. Надеюсь, что в этом ответе я смогу сказать разницу.

Лучший способ ответить на этот вопрос будет, задав несколько вопросов самому себе. так что давайте начнем:

. Каков результат для следующей программы:

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

, если вы говорите,

false
true

Я скажу, что вы right , но почему вы так сказали? и если вы говорите, что выходной сигнал,

true
false

Я скажу, что вы ошибочны , но я все равно спрошу вас, почему вы думаете, что это правильно?

Хорошо, попробуем ответить на этот вопрос:

Каков выход для следующей программы:

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

Now Если вы говорите,

false
true

Я скажу, что вы ошибочны , но почему это неправильно сейчас? правильным выходом для этой программы является

true
false

. Пожалуйста, сравните вышеуказанную программу и попытайтесь об этом подумать.

Хорошо. Теперь это может помочь (пожалуйста, прочтите следующее: напечатать адрес объекта - невозможно, но мы все же можем его использовать.)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

можете ли вы просто попытаться подумать о вывод последних трех строк в приведенном выше коде: для меня ideone напечатал это ( вы можете проверить здесь код ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

О! Теперь вы видите, что идентификаторHashCode (манго) равен идентификаторуHashCode (mango2). Но он не равен identityHashCode (mango3)

. Хотя все строковые переменные - mango, mango2 и mango3 - имеют одинаковое значение, который является «манго», identityHashCode() все еще не является одинаковым для всех.

Теперь попробуйте раскомментировать эту строку // mango2 = "mang"; и запустите его снова, на этот раз вы увидите, что все три identityHashCode() отличаются друг от друга. Хм, это полезный намек

, мы знаем, что если hashcode(x)=N и hashcode(y)=N => x is equal to y

, я не уверен, как java работает внутри, но я предполагаю, что это то, что произошло, когда я сказал:

mango = "mango";

java создал строку "mango", которая была указана (указана) переменной mango примерно так

mango ----> "mango"

Теперь в следующая строка, когда я сказал:

mango2 = "mango";

На самом деле она повторно использовала ту же строку "mango", которая выглядит примерно так

mango ----> "mango" <---- mango2

И манго, и манго2, указывающие на ту же ссылку Теперь когда я сказал

mango3 = new String("mango")

Фактически он создал совершенно новую ссылку (строку) для «манго». который выглядит примерно так:

mango -----> "mango" <------ mango2

mango3 ------> "mango"

, и поэтому, когда я выставляю значения для mango == mango2, он выдает true. и когда я вытащил значение для mango3 == mango2, он выпустил false (даже если значения были одинаковыми).

и когда вы раскоментировали строку // mango2 = "mang";, она фактически создала строку " mang ", который повернул наш график следующим образом:

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

Вот почему идентификаторHashCode для всех не одинок.

Надеюсь, это поможет вам, ребята. На самом деле, я хотел создать тестовый пример, где == fail и equals (). Пожалуйста, не стесняйтесь комментировать и дайте мне знать. Если я ошибаюсь.

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

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

object1.equals(object2) & lt; => object1 == object2

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

Реализация hashCode() при установлении равенства является частью Контракта объектов Java. Если вы работаете с коллекциями, а вы не реализовали hashCode(), могут возникнуть Strange Bad Things:

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().

Основное отличие между == и 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

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

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

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

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

Сравнение строк является распространенным сценарием использования оба метода == и equals. Поскольку класс java.lang.String переопределяет метод equals, он возвращает 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);

}
}

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

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

метод 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 содержат одни и те же данные, но ссылка не такая же, как и return false и ==. но если мы переопределили метод equals, чем

 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 для одного и того же случая, только мы переопределили

equals method.

< / blockquote>

сравнивает объект с базой содержимого (id) объекта

, но ==

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

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

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

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

 String w1 ="Sarat";
 String w2 ="Sarat";
 String w3 = new String("Sarat");

 System.out.println(w1.hashCode());   //3254818
 System.out.println(w2.hashCode());   //3254818
 System.out.println(w3.hashCode());   //3254818

 System.out.println(System.identityHashCode(w1)); //prints 705927765
 System.out.println(System.identityHashCode(w2)); //prints 705927765
 System.out.println(System.identityHashCode(w3)); //prints 366712642


 if(w1==w2)   //  (705927765==705927765)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

 if(w2==w3)   //  (705927765==366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints false


 if(w2.equals(w3))   //  (Content of 705927765== Content of 366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

== является -оператором , а equals() является методом .

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

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

Ваше желание, что вы хотите сделать, когда вы переопределите .equals (). Вы можете сравнить состояние вызывающего объекта с переданным в состоянии объекта или просто вызвать super.equals ()