// Object의 equals() 원본
public boolean equals(Object obj) {
    return (this == obj);  // 주소값 비교
}

public class EqualsExample {
    public static void main(String[] args) {
        // 기본 equals() - 주소 비교
        Object obj1 = new Object();
        Object obj2 = new Object();
        System.out.println(obj1.equals(obj2));  // false (다른 객체)

        // String의 equals() - 내용 비교 (오버라이딩됨)
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);       // false (주소 다름)
        System.out.println(s1.equals(s2));  // true  (내용 같음)
    }
}

public class Person {
    private long id;
    private String name;

    public Person(long id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;                   // 같은 객체면 true
        if (obj == null || getClass() != obj.getClass()) return false;

        Person other = (Person) obj;
        return this.id == other.id;  // id가 같으면 같은 사람
    }

    @Override
    public int hashCode() {
        return Long.hashCode(id);  // equals를 오버라이딩하면 hashCode도 함께!
    }
}

// 사용 예시
Person p1 = new Person(1L, "홍길동");
Person p2 = new Person(1L, "홍길동");
System.out.println(p1.equals(p2));  // true (id가 같으므로)

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

// String은 hashCode()도 오버라이딩 → 같은 문자열은 같은 해시코드
System.out.println(s1.hashCode());  // 96354
System.out.println(s2.hashCode());  // 96354

// identityHashCode()는 Object의 원래 hashCode() (주소 기반)
System.out.println(System.identityHashCode(s1));  // 예: 366712642
System.out.println(System.identityHashCode(s2));  // 예: 1829164700 (다름)

// Object의 toString() 원본
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

public class Card {
    private String suit;
    private int number;

    public Card(String suit, int number) {
        this.suit = suit;
        this.number = number;
    }

    // toString()을 오버라이딩하지 않으면
    // Card@15db9742 같은 형태로 출력

    @Override
    public String toString() {
        return suit + " " + number;
    }
}

Card card = new Card("SPADE", 1);
System.out.println(card);  // "SPADE 1" (println이 내부적으로 toString() 호출)

// 얕은 복사 (Shallow Copy) - 참조값만 복사
public class ShallowCopy implements Cloneable {
    int[] arr;

    public ShallowCopy(int[] arr) {
        this.arr = arr;
    }

    @Override
    public ShallowCopy clone() throws CloneNotSupportedException {
        return (ShallowCopy) super.clone();
    }
}

ShallowCopy original = new ShallowCopy(new int[]{1, 2, 3});
ShallowCopy copy = original.clone();
copy.arr[0] = 99;
System.out.println(original.arr[0]);  // 99 — 원본도 변경됨!

// 깊은 복사 (Deep Copy) - 참조하는 객체까지 복사
public class DeepCopy implements Cloneable {
    int[] arr;

    public DeepCopy(int[] arr) {
        this.arr = arr;
    }

    @Override
    public DeepCopy clone() throws CloneNotSupportedException {
        DeepCopy copy = (DeepCopy) super.clone();
        copy.arr = this.arr.clone();  // 배열도 별도로 복사
        return copy;
    }
}

DeepCopy original = new DeepCopy(new int[]{1, 2, 3});
DeepCopy copy = original.clone();
copy.arr[0] = 99;
System.out.println(original.arr[0]);  // 1 — 원본은 영향 없음

Card card = new Card("HEART", 3);
Class clazz = card.getClass();

System.out.println(clazz.getName());          // Card
System.out.println(clazz.getSimpleName());    // Card
System.out.println(clazz.getSuperclass());    // class java.lang.Object

// Class 객체를 얻는 3가지 방법
Class c1 = card.getClass();           // 인스턴스로부터
Class c2 = Card.class;               // 클래스 리터럴
Class c3 = Class.forName("Card");    // 문자열(FQCN)로부터

String a = "hello";
String b = a + " world";  // 새로운 String 인스턴스가 생성됨

// a는 여전히 "hello" — 원본이 변경된 것이 아님
System.out.println(a);  // "hello"
System.out.println(b);  // "hello world"

// 리터럴 방식 — String Pool에서 공유
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);  // true (같은 객체를 참조)

// new 방식 — 매번 새 객체 생성
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s3 == s4);      // false (서로 다른 객체)
System.out.println(s3.equals(s4)); // true  (내용은 같음)

// 빈 문자열 — 길이가 0인 char 배열을 저장
String empty = "";
System.out.println(empty.length());  // 0

// 초기화 권장 방식
String s = "";    // ○ 빈 문자열로 초기화
char c = ' ';     // ○ 공백으로 초기화

// char형은 빈 문자열 불가
// char c = '';   // ✕ 컴파일 에러

// 실용적인 활용 예시
String email = "  USER@example.COM  ";

// 공백 제거 + 소문자 변환으로 정규화
String normalized = email.trim().toLowerCase();
System.out.println(normalized);  // "user@example.com"

// @ 기준으로 분리
String[] parts = normalized.split("@");
System.out.println("아이디: " + parts[0]);   // "user"
System.out.println("도메인: " + parts[1]);   // "example.com"

// 기본형 → 문자열
String s1 = String.valueOf(100);       // "100"
String s2 = 100 + "";                  // "100" (간편하지만 성능은 valueOf가 나음)

// 문자열 → 기본형
int i = Integer.parseInt("100");       // 100
double d = Double.parseDouble("3.14"); // 3.14

// 진법 변환
int hex = Integer.parseInt("FF", 16);  // 255
int bin = Integer.parseInt("1010", 2); // 10

// String으로 문자열 연결 — 매번 새 객체 생성
String s = "";
for (int i = 0; i < 10000; i++) {
    s += i;  // 매 반복마다 새 String 객체 생성 → 느림
}

// StringBuffer로 문자열 연결 — 하나의 버퍼에서 편집
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 10000; i++) {
    sb.append(i);  // 같은 객체 내에서 편집 → 빠름
}
String result = sb.toString();

// 기본 생성자: 16문자 크기 버퍼
StringBuffer sb1 = new StringBuffer();

// 크기 지정
StringBuffer sb2 = new StringBuffer(100);  // 100문자 크기 버퍼

// 문자열로 초기화: 문자열 길이 + 16
StringBuffer sb3 = new StringBuffer("hello");  // 5 + 16 = 21 크기 버퍼

// 내부적으로 수행되는 배열 확장
char newValue[] = new char[newCapacity];
System.arraycopy(value, 0, newValue, 0, count);
value = newValue;

StringBuffer sb = new StringBuffer("abc");
sb.append("123").append("ZZ");
System.out.println(sb);  // "abc123ZZ"

// 주요 메서드
StringBuffer sb2 = new StringBuffer("Hello World");
sb2.insert(5, ",");         // "Hello, World"    — 지정 위치에 삽입
sb2.delete(5, 6);           // "Hello World"     — 범위 삭제
sb2.replace(6, 11, "Java"); // "Hello Java"      — 범위 치환
sb2.reverse();              // "avaJ olleH"      — 뒤집기

System.out.println(sb2.capacity());   // 버퍼 크기
System.out.println(sb2.length());     // 문자열 길이

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");

System.out.println(sb1 == sb2);       // false (다른 객체)
System.out.println(sb1.equals(sb2));  // false (주소 비교)

// 내용 비교 방법: toString()으로 String 변환 후 비교
String s1 = sb1.toString();
String s2 = sb2.toString();
System.out.println(s1.equals(s2));    // true (내용 비교)

// 실무에서는 대부분 StringBuilder 사용
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
System.out.println(sb.toString());  // "Hello World"

// 소수점 셋째 자리에서 반올림하여 둘째 자리까지 표시
double val = 90.7552;

// 1단계: 100을 곱한다  → 9075.52
// 2단계: round()       → 9076
// 3단계: 100.0으로 나눈다 → 90.76
double result = Math.round(val * 100) / 100.0;
System.out.println(result);  // 90.76

System.out.println(Math.round(1.5));   // 2   (더 큰 값으로)
System.out.println(Math.rint(1.5));    // 2.0 (가장 가까운 짝수)
System.out.println(Math.rint(2.5));    // 2.0 (가장 가까운 짝수)

// 음수에서의 동작
System.out.println(Math.round(-1.5));  // -1  (더 큰 값으로)
System.out.println(Math.rint(-1.5));   // -2.0 (가장 가까운 짝수)
System.out.println(Math.floor(-1.5));  // -2.0 (음수 방향으로 내림)
System.out.println(Math.ceil(-1.5));   // -1.0 (양수 방향으로 올림)

// 랜덤 정수 생성 (1 ~ 6)
int dice = (int)(Math.random() * 6) + 1;

// 두 점 사이의 거리
double distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));

int a = Integer.MAX_VALUE;

// 일반 연산 — 오버플로우를 알 수 없음
System.out.println(a + 1);  // -2147483648 (오버플로우, 에러 없음)

// Exact 메서드 — 오버플로우 시 예외 발생
try {
    Math.addExact(a, 1);  // ArithmeticException!
} catch (ArithmeticException e) {
    System.out.println("오버플로우 발생: " + e.getMessage());
}

// equals() — 내용 비교 (오버라이딩됨)
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);
System.out.println(i1.equals(i2));  // true
System.out.println(i1 == i2);      // true (캐싱: -128 ~ 127)

Integer i3 = Integer.valueOf(200);
Integer i4 = Integer.valueOf(200);
System.out.println(i3 == i4);      // false (캐싱 범위 초과)
System.out.println(i3.equals(i4)); // true

// compareTo() — 크기 비교
System.out.println(i1.compareTo(i3));  // 음수 (i1 < i3)

// 유용한 상수
System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Integer.MIN_VALUE);  // -2147483648
System.out.println(Integer.SIZE);       // 32 (비트 수)
System.out.println(Integer.BYTES);      // 4 (바이트 수)

// Number의 추상 메서드 — 모든 숫자 래퍼가 구현
public abstract int intValue();
public abstract long longValue();
public abstract float floatValue();
public abstract double doubleValue();

// 기본형으로 변환 (주로 사용)
int i = Integer.parseInt("100");
long l = Long.parseLong("100");
double d = Double.parseDouble("3.14");

// 래퍼 클래스로 변환
Integer iObj = Integer.valueOf("100");
Double dObj = Double.valueOf("3.14");

// 진법 변환
int hex = Integer.parseInt("FF", 16);     // 255
int oct = Integer.parseInt("77", 8);      // 63
int bin = Integer.parseInt("11001", 2);   // 25

// 오토박싱: 기본형 → 래퍼 클래스 (자동)
Integer num = 100;  // 컴파일러가 Integer.valueOf(100)으로 변환

// 언박싱: 래퍼 클래스 → 기본형 (자동)
int n = num;        // 컴파일러가 num.intValue()로 변환

// 연산에서의 오토박싱/언박싱
Integer a = 10;
Integer b = 20;
int sum = a + b;  // a.intValue() + b.intValue()로 변환

// 작성한 코드                     // 컴파일러가 변환한 코드
ArrayList<Integer> list;            ArrayList<Integer> list;
list.add(100);                  →   list.add(Integer.valueOf(100));
int val = list.get(0);          →   int val = list.get(0).intValue();