Разница между операторами Equals/equals и ==?

Ответ 1

Предполагая, что типы a и b являются ссылочными типами:

• В Java == всегда будет сравниваться для идентификации - т.е. являются ли эти два значения ссылками на один и тот же объект. Это также называется ссылочным равенством. Java не имеет никакой пользовательской перегрузки оператора.

• В С# это зависит. Если нет перегруженного оператора, который его обрабатывает, == будет вести себя как Java (т.е. Для сравнения для ссылочного равенства). Однако, если есть перегрузка, которая соответствует типам времени a и b для компиляции (например, если они оба объявлены как строки), то будет вызвана перегрузка. Это может вести себя так, как хочет, но обычно реализует равенство ценности (т.е. a и b могут ссылаться на разные, но равные значения, и оно все равно возвращает true).

В обоих языках a.Equals(b) или a.Equals(b) вызовет виртуальный Equals/Equals метод, объявленный Object, если только более сложная перегрузка не была введена типом времени a, Это может быть или не быть переопределено в типе времени выполнения объекта, на который ссылается a. В .NET и Java реализация в Object также проверяет идентификатор. Обратите внимание, что это зависит от типа времени выполнения, а не от типа времени компиляции, от которого зависит разрешение перегрузки.

Конечно, если a - null, вы получите NullReferenceException/NullPointerException при попытке вызвать a.Equals(b) или a.Equals(b).

Ответ 2

Оператор == проверяет, являются ли два объекта в точности тем же самым объектом, который не подходит для большинства случаев. Метод Equals сможет сравнивать как объект внутри

Пример:

class Mycar
{
  string color;
  Mycar(string str)
 {
   color = str;
 }
}   

Mycar a = new Mycar("blue");
Mycar b = new Mycar("blue");
a==b // Returns false
a.Equals(b) // Returns true

Ответ 3

Это зависит от типов a и b.

В частности, Equals является виртуальным методом, поэтому его поведение не зависит от типов времени компиляции a и b.

В Java == всегда будет сравнивать по ссылке, что не обязательно то, что вы хотите, особенно для строк.

В С#, == может быть перегружен, но не является виртуальным (это метод static). Поэтому, если a или b объявлены как object, он будет сравнивать по ссылке, даже если их фактический тип перегружает operator ==.

Кроме того, a.Equals(b) будет вызывать NullReferenceException (NullPointerException в Java), если a null.

Ответ 4

String a = "toto".Substring(0, 4);
String b = "toto";
Object aAsObj = a;
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(a == b);
Assert.IsFalse(aAsObj == b);
Assert.IsTrue(aAsObj.Equals(b));

Этот тест проходит в .NET, трюк заключается в том, что Equals - это метод, тогда как == - это метод static, поэтому aAsObj == b используйте

static bool Object.operator==(object a, object b) //Reference comparison

тогда как a == b используйте

static bool String.operator==(string a, string b) //String comparison

но a.Equals(b) или aAsObj.Equals(b) всегда используют:

bool String.Equals(Object obj) //String comparison

Ответ 5

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

Метод equals() может быть переопределен для сравнения объектов. Например, в Strings метод возвращает true, если строки содержат одну и ту же строку, даже если они являются разными строковыми объектами. Вы можете делать похожие вещи со своими собственными объектами.

o.equals() выдаст исключение, если o - нулевая ссылка.

Ответ 6

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

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

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

1. Reflexive: для любой ненулевой ссылки x x.equals(x) должен возвращать true.

2. Симметричный: для любой ненулевой ссылки x и y, если x.equals(y) истинно, то y.equals(x) должно возвращать true.

3. Transitive: для любой ненулевой ссылки x, y и z, если x.equals(y) истинно, y.equals(z) истинно, то x.равнения (z) должны возвращать true.

4. Согласовано: для любой ненулевой ссылки x и y несколько вызовов x.equals(y) последовательно возвращают true или последовательно возвращают false, не изменяя информацию, предоставленную для сравнений сравнений.

5. Для любой ненулевой ссылки x, x.equals(null) должен возвращать false. ПРИМЕЧАНИЕ. Если o1.equals(o2) истинно, то o1.hashcode() == o2.hashcode(), но обратное может быть или не быть истинным.

Примеры:

Целое число я = новое целое число (10); Целое число j = i;

в приведенном выше коде. я == j истинно, потому что и i, и j относятся к одному и тому же объекту.

Целое число я = новое целое число (10); Целое число j = новое целое число (10);

В приведенном выше коде я == j является FALSE, потому что, хотя оба они имеют значение 10, это два разных объекта. Но i.equals(j) вернет true.

Использование автоматического бокса

Целое число я = 10;
Целое число j = 10;
Boolean b = (i == j);
System.out.println(b);

Это вернет TRUE, потому что будут объединены целые числа между диапазонами от -127 до 128, поэтому в этом случае оба являются одинаковыми объектами (JVM не собирается создавать новый объект, он будет извлекать его из пула).

Класс String переопределяет метод equals, поэтому здесь приведен пример равенства vs. == String s1 = new String ( "abc" ); Строка s2 = новая строка ( "abc" );

ПРИМЕЧАНИЕ. Строки создаются в пуле констант String, поэтому, когда мы создаем как String s = "abc" , он проверяет пул, вызывая собственный метод intern(), для его существования в существующем пуле, если он не найден ни один String, тогда он будет создавать новый, но если мы вызовет новый оператор, то он создаст одну новую строку, независимо от проверки пула для существования.

  public class StringEqualityTest {
    public static void main(String []a){

    String s1=new String("abc");
    String s2=new String("abc");

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

     String s3="abc";
     String s4="abc";

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

       }

       }

ВЫВОД: s1.equals(s2): true s1 == s2: false s3.equals(s4): true s3 == s4: true

Ответ 7

== использует ссылку объекта, или целое число /float и т.д., затем сравнивает фактическое число. Технически это просто сравнивает то, что находится в памяти. В то время как .equals использует метод внутри класса объекта для сравнения объектов, он может быть переопределен для ваших отдельных классов. Кроме того, поскольку массивы также имеют дело со ссылками, также полезно не использовать array1[i] = array2[i], использовать arraycopy или clone(). Я думаю, что .equals также может использоваться с массивами

Ответ 8

== проверяет ссылку на объект, в основном он сравнивает хэш-коды. Equals использует содержимое объекта. Помните, что мы должны переопределить метод .equals соответственно в нашем классе.

Ответ 9

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

Ответ 10

== проверяет, ссылаются ли ссылки на один и тот же объект в памяти

Теперь

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

В классах, подобных String, переопределенный метод проверяет правильность строковых литералов или нет. Поэтому в основном это можно использовать для проверки того, является ли значение одинаковым или нет.

Ответ 11

==, Он возвращает значение хеш-кода в соответствии с их адресами, поэтому разные адреса, даже если строки или любые данные, которые аналогичны, также возвращают false.... Это помогает полностью для условий, возвращает логическое значение стоимость.