동일성과 동등성 : == 와 equals()

 

매일메일 백엔드 질문을 참고해 개인적으로 학습한 내용을 정리하였습니다.
오류가 있다면 언제든 피드백 주시면 바로 반영하겠습니다..!

 

 

 

시작하기전에

 

JAVA로 코딩을 하다보면 객체를 비교해야 하는 순간이 정말 많은데 이 때 '동일성'과 '동등성'이라는 두 개념을 명확히 이해하지 못하면, 예측할 수 없는 곳에서 오류가 발생해서 고생할 수 있음

 

Java에서는 이 두 개념을 == 연산자와 equals() 메서드로 구분함

 

동일성(Identity)과 동등성(Equality)

 

동일성

 

"두 개의 객체가 메모리 상에서 완전히 같은 존재인가?" 를 의미함

 

=> 즉, 두 변수가 메모리의 동일한 주소를 가리키고 있는지를 확인하는 개념

 

 

동등성

 

"두 개의 객체가 논리적으로 같은 내용(값)을 가지고 있는가?" 를 의미함

 

=> 메모리 주소는 다르더라도, 객체가 가진 핵심적인 속성값이 같다면 동등하다고 판단함

 

 

동일성 비교 : == 연산자

 

== 연산자는 두 변수가 참조하는 객체의 메모리 주소 값을 비교함

따라서, == 연산의 결과가 true라면, 두 변수는 정확히 동일한 객체 인스턴스를 가리키고 있다는 의미임

 

public class IdentityTest {
    public static void main(String[] args) {
        Apple apple1 = new Apple(100); // 1번 사과 객체 생성
        Apple apple2 = new Apple(100); // 2번 사과 객체 생성 (1번과 내용은 같지만 다른 객체)
        Apple apple3 = apple1;         // 3번 사과는 1번 사과의 메모리 주소를 가리킴

        // apple1과 apple2는 내용은 같지만, 서로 다른 메모리 공간에 할당된 별개의 객체입니다.
        System.out.println("apple1 == apple2: " + (apple1 == apple2)); // 결과: false

        // apple3은 apple1이 가리키는 객체를 똑같이 가리킵니다.
        System.out.println("apple1 == apple3: " + (apple1 == apple3)); // 결과: true
    }
}

class Apple {
    private final int weight;
    public Apple(int weight) {
        this.weight = weight;
    }
    // ... equals()와 hashCode()는 잠시 후 살펴봅니다.
}

 

매일메일의 예시코드로 살펴보면 위 코드에서 apple1과 apple2는 무게가 100으로 같지만, new 키워드를 통해 각각 독립적인 객체로 생성되었음

 

=> 둘의 메모리 주소는 다르므로 == 비교 결과 false임

 

반면, apple3은 apple1의 주소 값을 그대로 할당받았기 때문에 == 비교 결과가 true가 됨

 

동등성 비교 : euqals() 메서드

 

equals() 메서드는 두 객체의 내용이 논리적으로 같은지를 비교함

하지만, 여기서는 함정이 있는데 바로 Object 클래스의 equals() 메서드 기본 동작 방식임

 

---

 

모든 자바 클래스는 명시하지 않아도 Object 클래스를 상속받음 

 

// Object.java
public class Object {
    // ...
    public boolean equals(Object obj) {
        return (this == obj); // 기본적으로 == 연산과 동일하게 동작한다!
    }
    // ...
}

 

Object 클래스에 정의된 equals() 메서드는 위와 같은데 기본 구현은 == 연산자를 사용한 동일성 비교인 것을 알 수 있음

 

따라서, 위에서 직접 만든 Apple 클래스에서 equals()를 재정의(Overriding)하지 않으면, apple1.equals(apple2)는 apple1 == apple2 와 똑같이 동작하여 false를 반환하게됨

 

import java.util.Objects;

public class Apple {
    private final int weight;

    public Apple(int weight) {
        this.weight = weight;
    }

    // Object의 equals() 메서드를 재정의
    @Override
    public boolean equals(Object o) {
        // 1. 동일성 체크: 같은 객체면 무조건 true (성능 최적화)
        if (this == o) return true;

        // 2. null 체크 및 클래스 타입 체크: 비교 불가능한 경우 false
        if (o == null || getClass() != o.getClass()) return false;

        // 3. 형 변환 후 내용 비교: 실제 필드 값을 비교하여 동등성을 판단
        Apple apple = (Apple) o;
        return weight == apple.weight;
    }

    // equals를 재정의했다면, 반드시 hashCode도 함께 재정의해야 합니다!
    @Override
    public int hashCode() {
        return Objects.hash(weight);
    }

    public static void main(String[] args) {
        Apple apple = new Apple(100);
        Apple anotherApple = new Apple(100);

        // 재정의된 equals()는 메모리 주소가 아닌 '무게(weight)'를 비교합니다.
        System.out.println(apple.equals(anotherApple)); // 결과: true
    }
}

 

 

객체의 논리적 내용을 비교하고 싶다면, 위 코드처럼 equals() 메서드를 클래스의 목적에 맞게 재정의해야함

 

=> 여기서는 '두 사과는 무제가 같으면 동등하다' 라는 규칙을 적용하였음

 

equals()를 위와 같이 재정의함으로써, 이제 apple과 anotherApple은 비록 다른 객체일지라도 '무게가 같다'는 논리적 기준에 따라 동등하다고 판단할 수 있음

 

equals()를 재정의했다면, 반드시 hashCode()도 함께 재정의 해야함

=> Java에서 equals()와 hashCode()의 규약이 있음

1. equals() 비교 결과가 true인 두 객체는 반드시 동일한 hashCode() 값을 반환해야 한다

2. hashCode()가 동일한 두 객체라고 해서 equals() 비교 결과가 반드시 true일 필요는 없다.

=> hashCode()는 보통 int 값을 반환하므로 int 값의 범위가 넘어가는 객체의 수를 다루게되면 서로 다른 객체라도 동일한 해시코드 값을 가질 수 밖에 없는 상황이 생김
(해시 충돌)

=> HashSet, HashMap과 같은 해시 기반 컬렉션들은 객체를 저장하거나 검색할 때 hashCode()를 먼저 사용하여 성능을 높이기 때문에 이 규약을 어기면, 컬렉션이 객체를 제대로 찾지 못하는 등의 심각한 문제가 발생할 수 있기 때문에 꼭 equals()를 재정의할 때는 hashCode()도 함께 재정의 해줘야함

=> 해시 기반 컬렉션의 내부 동작을 살펴보면 객체를 넣을 때 hashCode()로 해시값 계산 후 이를 이용해 버킷 위치를 찾음, 만약 해당 버킷에 같은 해시값의 객체가 이미 있으면 equals()로 최종 비교하여 같은 객체인지 판단하고 같으면 덮어쓰기, 다르면 체이닝(리스트에 추가)

=> 그래서 해시 충돌이 발생하면 한 버킷 안에 저장되는 객체 수가 많아지므로 equals()로 일일이 비교해야 하니 O(1)에 가깝던 성능이 O(n)에 가까워짐

(데이터 양이 커질수록 성능 저하 체감이 큼)

 

String은 객체인데 == 비교해도 되던데?

 

String은 객체인데 ==로 비교해도 잘 되는 경우가 있음

=> 이는 문자열 상수 풀(String Constant Pool)이라는 특별한 메모리 영역 때문임

 

public class StringComparison {
    public static void main(String[] args) {
        // "안녕하세요" 리터럴은 String Constant Pool에 저장되고, str1과 str2는 같은 주소를 참조합니다.
        String str1 = "안녕하세요";
        String str2 = "안녕하세요";

        // new 키워드는 Heap 메모리에 새로운 객체를 강제로 생성합니다.
        String str3 = new String("안녕하세요");

        // 동일성 비교 (메모리 주소 비교)
        System.out.println(str1 == str2); // true
        System.out.println(str1 == str3); // false

        // 동등성 비교 (내용 비교) - String 클래스에는 equals()가 이미 잘 재정의되어 있습니다.
        System.out.println(str1.equals(str3)); // true
    }
}

 

코드 리터럴("...")로 생성한 문자열은 컴파일 시점에 문자열 상수 풀(String Constant Pool)에 저장되어 재사용됨

 

=> 위 코드에서 str1과 str2는 같은 주소(동일한 문자열 리터럴)를 참조하여 == 비교가 true가 나옴

 

하지만 new String()은 무조건 Heap 영역에 새 객체를 만들기 때문에 주소가 달라 false가 됨

 

이러한 동작 방식의 차이 때문에 버그가 발생하기 쉬우므로 문자열의 내용을 비교할 때는 혼동을 피하기 위해 항상 equals() 메서드를 사용하는 것이 안전함

 

Integer 같은 래퍼 클래스는 어떻게 비교?

 

Integer, Long과 같은 래퍼 클래스도 객체이므로 원칙적으로 equals()를 사용해 값을 비교해야함

 

=> 하지만, Integer의 경우에도 String 처럼 캐싱(caching) 기능이 존재

(기본적으로 -128 ~ 127 까지의 Integer 값은 내부 캐시에 저장되어 공유됨)

 

Integer i1 = 100; // Integer.valueOf(100)으로 변환 (오토박싱)
Integer i2 = 100;
System.out.println(i1 == i2); // true (캐시된 범위 내의 값이므로 같은 객체 참조)

Integer i3 = 200;
Integer i4 = 200;
System.out.println(i3 == i4); // false (캐시 범위를 벗어나 새로운 객체 생성)

System.out.println(i3.equals(i4)); // true (값 자체는 같으므로 equals()는 true)

 

위 코드처럼 특정 범위를 벗어나면 == 비교 결과가 달라지므로, 래퍼 클래스의 값을 비교할 때도 일관성 있고 안전한 equals() 메서드를 사용해야함

 

정리

 

구분	== 연산자	equals() 메서드
비교 대상	메모리 주소 값	객체의 논리적 내용
개념	동일성	동등성
사용	원시 타입(primitive type) 비교	객체(Object)의 내용 비교
주의사항	String, Wrapper 클래스에 사용 금지	사용자 정의 클래스는 hashCode() 와 함께 반드시 재정의