equals() vs ==

// ── == on primitives — compares values directly: ─────────────────────
int x = 5;
int y = 5;
int z = 6;
System.out.println(x == y);  // true  — same value
System.out.println(x == z);  // false — different values

// ── == on objects — compares references (memory addresses): ───────────
String a = new String("Hello");
String b = new String("Hello");
String c = a;                    // c and a point to the SAME object

System.out.println(a == b);   // false — different objects, same content
System.out.println(a == c);   // true  — same object (same address)
System.out.println(b == c);   // false — b and a are different objects

// ── == with object values — only true if same instance: ───────────────
Object obj1 = new Object();
Object obj2 = new Object();
Object obj3 = obj1;           // alias

System.out.println(obj1 == obj2);  // false — different instances
System.out.println(obj1 == obj3);  // true  — same instance

// ── Autoboxing cache trap — Integer -128 to 127: ──────────────────────
Integer i1 = 100;
Integer i2 = 100;
System.out.println(i1 == i2);   // true  — cached, same object

Integer i3 = 200;
Integer i4 = 200;
System.out.println(i3 == i4);   // false — outside cache, different objects!
System.out.println(i3.equals(i4)); // true  — same value

// ── Always use equals() for wrapper types: ────────────────────────────
Integer a1 = Integer.valueOf(200);
Integer b1 = Integer.valueOf(200);
System.out.println(a1.equals(b1));   // true  — correct value comparison

// ── Object.equals() default — reference identity: ────────────────────
class Unoverridden {
    int value;
    Unoverridden(int v) { this.value = v; }
    // No equals() override — uses Object.equals() which uses ==
}

Unoverridden u1 = new Unoverridden(5);
Unoverridden u2 = new Unoverridden(5);
System.out.println(u1.equals(u2));  // false — different objects
System.out.println(u1.equals(u1));  // true  — same object

// ── String overrides equals() — content comparison: ───────────────────
String s1 = new String("Hello");
String s2 = new String("Hello");
System.out.println(s1.equals(s2));  // true  — same content

// ── Integer overrides equals() — same int value: ─────────────────────
Integer n1 = new Integer(42);
Integer n2 = new Integer(42);
System.out.println(n1.equals(n2));  // true  — same value
System.out.println(n1 == n2);       // false — different objects

// ── Custom equals() implementation: ──────────────────────────────────
public class Point {
    private final double x;
    private final double y;

    public Point(double x, double y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;                          // reflexivity
        if (obj == null || getClass() != obj.getClass()) return false;
        Point other = (Point) obj;
        return Double.compare(x, other.x) == 0
            && Double.compare(y, other.y) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);   // must match equals()
    }
}

Point p1 = new Point(3.0, 4.0);
Point p2 = new Point(3.0, 4.0);
Point p3 = new Point(1.0, 2.0);

System.out.println(p1.equals(p2));  // true  — same coordinates
System.out.println(p1.equals(p3));  // false — different coordinates
System.out.println(p1.equals(null));// false — null safe

// ── null safety — put non-null on the left: ───────────────────────────
String userInput = null;
// userInput.equals("admin")     — NullPointerException!
"admin".equals(userInput);       // false — safe, no NPE
Objects.equals(userInput, "admin"); // false — safe, handles null on either side

// ── When to use == (reference identity): ─────────────────────────────

// 1. Null checks — always use ==:
String s = getNullableString();
if (s == null) {
    System.out.println("String is null");
}
if (s != null) {
    System.out.println(s.length());
}

// 2. Enum comparisons — == is correct and preferred:
enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }
Day today = Day.WED;
if (today == Day.WED) {                    // ✓ correct
    System.out.println("Midweek");
}
if (today.equals(Day.WED)) {               // also works, but == preferred

}

// 3. Checking aliases (same instance):
List<String> list1 = new ArrayList<>();
List<String> list2 = list1;
if (list1 == list2) {
    System.out.println("Same list object");
}

// ── When to use equals() (content comparison): ────────────────────────

// Strings — always use equals():
String input = getUserInput();
if ("admin".equals(input)) {
    grantAccess();
}

// Wrapper types:
Integer count = getCount();
if (count != null && count.equals(0)) {
    System.out.println("Empty");
}

// Custom objects:
Customer c1 = new Customer("Alice", "alice@x.com");
Customer c2 = new Customer("Alice", "alice@x.com");
System.out.println(c1.equals(c2));   // depends on Customer.equals() implementation

// ── Objects.equals() — safe for possibly null references: ─────────────
String a = null;
String b = "hello";
String c = null;

System.out.println(Objects.equals(a, b));  // false — null vs "hello"
System.out.println(Objects.equals(a, c));  // true  — both null
System.out.println(Objects.equals(b, "hello")); // true — same content

// ── Comparison summary: ───────────────────────────────────────────────
//
// Situation                    Use
// ──────────────────────────── ─────────────────────────────
// Primitives (int, double...)  ==
// Null check                   == null or != null
// Enum constants               ==
// String content               .equals() or "literal".equals(var)
// Integer, Long, Double...     .equals()
// Custom objects               .equals() (if correctly overridden)
// Either side might be null    Objects.equals(a, b)
// Same object check            ==