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

import static java.lang.System.*; 
public class A { 
    public static void main(String[] args){ 
        B b1 = new B("one","two"); 
        B b2 = new B("one", "two"); 
        B b3 = b1; 
        // ==
        out.println(b1 == b2);      // false
        out.println(b1 == b3);      // true
        out.println(b2 == b3);      // false
        // equals
        out.println(b1.equals(b2)); // false
        out.println(b1.equals(b3)); // true
        out.println(b3.equals(b2)); // false
   } 
} 
class B { 
    public B(String prop1, String prop2){ 
        this.prop1 = prop1; 
        this.prop2 = prop2; 
    } 
    private String prop1 = null; 
    private String prop2 = null; 
} 

Т.к метод equals() не переопределен, то данный метод сравнивает ссылки, так же как и оператор ==. Это можно увидеть, если взглянуть исходный код метода equals класса Object:

public boolean equals(Object obj) { 
    return (this == obj); 
}

А если equals() переопределен, возьмем, например, класс Integer:

public boolean equals(Object obj) { 
    if (obj instanceof Integer) { 
        return value == ((Integer)obj).intValue(); 
    } 
    return false; 
} 

то:

Integer a = new Integer(6); 
Integer b = new Integer(6); 
System.out.println(a == b);  
// false т.к. это разные объекты с разными ссылками 
System.out.println(a.equals(b));  
// true, т.к equals() переопределен и сравниваются уже не ссылки

Чтобы сравнивать классы, нужно переопределить метод equals() (а тогда следует переопределить и hashCode()).

Метод equals() обозначает отношение эквивалентности объектов. Эквивалентным называется отношение, которое является симметричным, транзитивным и рефлексивным. Но мы можем переопределять метод equals, задавая логику сравнения двух объектов. Отличия equals() от операции == в классе Object нет. Eсли объект ни на что не ссылается(null), то вызов метода equals этого объекта приведет к NullPointerException. У String equals перегружен. Оператор == (в случае с примитивными типами данных) сравнивает значения переменных и возвращает результат, НО в случае со ссылочными типами данных (объекты, массивы и т.д.) сравнивает ссылки на объекты в памяти компьютера, и на основании равенства или неравенства ссылок возвращает результат (true или false).

Метод equals() в сравнении с операцией ==

Метод equals сравнивает символы из объекта типа String, а операция == - две ссылки на объекты, определяя ссылаются ли они на один и тот же экземпляр.

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

// метод equals() в сравнении с операцией ==
public class EqualsNotEqualTo {
    public static void main(String[] args) {
        String s1 = "Сравнение";
        String s2 = new String(s1);
        System.out.println(s1 + " равно " + s2 + " -> " + s1.equals(s2));
        System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));
    }
}

Переменная s1 ссылается на экземпляр класса String, созданный присваиванием ей строкового литерала "Сравнение". А объект, на который ссылается переменная s2, создается с использованием переменной s1 в качестве инициализатора.

Таким образом, содержимое обоих объектов типа String одинаково, но это разные объекты. Следовательно, переменные s1 и s2 ссылаются не на один и тот же объект, поэтому они не равны, в сравнении операции ==.

Результат:

Сравнение равно Сравнение -> true
Сравнение == Сравнение -> false