" Smalltalk에서는 숫자도 객체 "
3 + 4           " 3이라는 객체에 +4 메시지를 보냄 "
5 timesRepeat: [ Transcript show: 'Hello' ]

int a = 10;    // 스택에 4바이트로 직접 저장
int b = a + 5; // CPU 레지스터에서 직접 연산

// Primitive: 성능이 필요한 곳
int count = 0;
for (int i = 0; i < 1_000_000; i++) {
    count += i;  // 빠른 CPU 연산
}

// Object: 객체지향이 필요한 곳
Object obj = new Integer(42);  // 다형성 활용

// 1990년대 후반 Java 코드
Vector numbers = new Vector();  // 제네릭 없던 시절

numbers.add(10);        // ❌ 컴파일 에러! int는 Object가 아님
numbers.add(new Integer(10));  // ✅ 이렇게 해야 함

// 꺼낼 때도 번거로움
Integer wrapped = (Integer) numbers.get(0);
int value = wrapped.intValue();

List<Integer> numbers = new ArrayList<Integer>();

// 우리가 작성한 코드
List<Integer> list = new ArrayList<Integer>();

// 컴파일 후 바이트코드 (Type Erasure)
List list = new ArrayList();  // 타입 정보가 지워짐

List<int> numbers;  // ❌ 불가능!
// 컴파일 후 List가 되는데, int는 Object를 상속받지 않음

// Before Java 5: 지옥의 수동 Boxing
List<Integer> list = new ArrayList<Integer>();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
int sum = list.get(0).intValue() + list.get(1).intValue();

// After Java 5: Autoboxing의 축복
List<Integer> list = new ArrayList<>();
list.add(1);  // 컴파일러가 알아서 변환
list.add(2);
list.add(3);
int sum = list.get(0) + list.get(1);  // 자동 unboxing

int x = 10;              // Value Type (스택)
object obj = x;          // Boxing 발생 (힙에 복사)
int y = (int)obj;        // Unboxing

// 제네릭에서 primitive 직접 사용 가능!
List<int> numbers = new List<int>();  // ✅ 가능

val x: Int = 10          // 컴파일 시 primitive int로 최적화
val y: Int? = 10         // nullable이면 Integer로 boxing
val list: List<Int>      // 컬렉션 내부에서는 Integer

// 코드상으로는 구분 없이 사용
fun sum(a: Int, b: Int): Int = a + b

val x: Int = 10          // primitive로 컴파일
val list: List[Int]      // 내부적으로 boxing 발생

// Value Class로 boxing 없이 래핑 가능
class Meter(val value: Double) extends AnyVal

// 현재 Java
record Point(int x, int y) {}  // 항상 힙에 할당

// Valhalla 이후 (예상)
value record Point(int x, int y) {}  // 스택/인라인 가능

// Primitive class (Universal Generics)
List<int> numbers;  // ✅ 드디어 가능해질 예정!

int a = 10;        // Stack에 직접 10이라는 값 저장
int b = a;         // b에도 10이라는 값이 복사됨 (독립적)
a = 20;            // a만 변경됨, b는 여전히 10

Integer x = new Integer(10);  // Heap에 객체 생성, Stack에는 주소만 저장
Integer y = x;                // y도 같은 객체를 참조

Stack                    Heap
+-------+               +----------------+
|  x    | ─────────────>|  Integer 객체   |
+-------+               |  value = 10    |
|  y    | ─────────────>|                |
+-------+               +----------------+

// 컴파일 에러! 제네릭은 참조 타입만 가능
List<int> numbers = new ArrayList<>();  // ❌

// Wrapper Class 사용
List<Integer> numbers = new ArrayList<>();  // ✅

// 원시 타입은 null 불가
int value = null;  // ❌ 컴파일 에러

// Wrapper는 null 가능 - "값이 없음"을 표현할 수 있다
Integer value = null;  // ✅

// 문자열 → 정수 변환
int parsed = Integer.parseInt("123");

// 진법 변환
String binary = Integer.toBinaryString(10);  // "1010"
String hex = Integer.toHexString(255);       // "ff"

// 비트 연산
int bitCount = Integer.bitCount(15);         // 4 (1111)
int highestBit = Integer.highestOneBit(10);  // 8

Boxing:   Primitive → Wrapper    (포장)
Unboxing: Wrapper → Primitive    (개봉)

// Boxing: int → Integer
int primitiveValue = 10;
Integer boxedValue = new Integer(primitiveValue);  // deprecated
Integer boxedValue2 = Integer.valueOf(primitiveValue);  // 권장

// Unboxing: Integer → int
Integer wrapped = Integer.valueOf(20);
int unwrapped = wrapped.intValue();

// Autoboxing
Integer num = 10;  // 컴파일러가 Integer.valueOf(10)으로 변환

// Auto-unboxing
int value = num;   // 컴파일러가 num.intValue()로 변환

// 우리가 작성한 코드
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
int sum = list.get(0) + list.get(1);

// 컴파일러가 변환한 코드 (개념적)
List<Integer> list = new ArrayList<>();
list.add(Integer.valueOf(1));           // Autoboxing
list.add(Integer.valueOf(2));           // Autoboxing
int sum = list.get(0).intValue()        // Auto-unboxing
        + list.get(1).intValue();       // Auto-unboxing

public class BoxingExample {
    public static void main(String[] args) {
        // Autoboxing
        Integer a = 100;

        // Auto-unboxing
        int b = a;

        // 연산 시 unboxing
        int c = a + 10;
    }
}

public static void main(java.lang.String[]);
  Code:
     0: bipush        100
     2: invokestatic  #2  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
     5: astore_1

     6: aload_1
     7: invokevirtual #3  // Method java/lang/Integer.intValue:()I
    10: istore_2

    11: aload_1
    12: invokevirtual #3  // Method java/lang/Integer.intValue:()I
    15: bipush        10
    17: iadd
    18: istore_3
    19: return

Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true (?!)

Integer c = 128;
Integer d = 128;
System.out.println(c == d);  // false

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer[] cache;

    static {
        // high 값은 JVM 옵션으로 조절 가능
        int h = 127;
        String integerCacheHighPropValue =
            VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
        }
        high = h;

        // -128 ~ high 범위의 Integer 객체를 미리 생성
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }
}

                    Integer.valueOf(100)
                            │
                            ▼
                 ┌──────────────────────┐
                 │  -128 <= 100 <= 127? │
                 └──────────────────────┘
                            │ Yes
                            ▼
              ┌─────────────────────────────┐
              │  IntegerCache.cache[228]    │
              │  (100 + 128 = 228번 인덱스)   │
              │  미리 생성된 객체 반환         │
              └─────────────────────────────┘

                    Integer.valueOf(1000)
                            │
                            ▼
                 ┌──────────────────────┐
                 │  -128 <= 1000 <= 127?│
                 └──────────────────────┘
                            │ No
                            ▼
              ┌─────────────────────────────┐
              │     new Integer(1000)       │
              │     새로운 객체 생성          │
              └─────────────────────────────┘

// Long도 캐시 사용
Long x = 127L;
Long y = 127L;
System.out.println(x == y);  // true

Long p = 128L;
Long q = 128L;
System.out.println(p == q);  // false

# JVM 옵션으로 캐시 상한 조절
java -XX:AutoBoxCacheMax=1000 MyApp

// 캐시 상한을 1000으로 설정한 경우
Integer a = 1000;
Integer b = 1000;
System.out.println(a == b);  // true (캐시 범위 내)

Integer a = 1000;
Integer b = 1000;

// 객체 주소 비교 - 다른 객체이므로 false
System.out.println(a == b);        // false

// 값 비교 - 같은 값이므로 true
System.out.println(a.equals(b));   // true

// 권장: Objects.equals() 사용 (null-safe)
System.out.println(Objects.equals(a, b));  // true

Integer value = null;

// 컴파일은 되지만 런타임에 NPE!
int primitive = value;  // value.intValue() → NPE

// 안전한 처리
int safe = (value != null) ? value : 0;

// Java 9+ Optional 활용
int safe2 = Optional.ofNullable(value).orElse(0);

public class Order {
    private Integer quantity;  // DB nullable 컬럼

    public int getQuantity() {
        return quantity;  // quantity가 null이면 NPE!
    }
}

// 안전한 버전
public int getQuantity() {
    return quantity != null ? quantity : 0;
}

Integer a = true ? 1 : new Integer(2);
// 1이 Integer.valueOf(1)로 boxing됨

// 더 나쁜 케이스
Integer result = condition ? null : 0;  // 0이 boxing됨

public void process(int value) {
    System.out.println("primitive");
}

public void process(Integer value) {
    System.out.println("wrapper");
}

process(10);              // "primitive" - 정확히 매칭
process(Integer.valueOf(10));  // "wrapper"
process(null);            // "wrapper" - primitive는 null 불가

int primitive = 10;      // 4 bytes

Integer wrapper = 10;    // 16+ bytes (64bit JVM 기준)
                         // - 객체 헤더: 12 bytes
                         // - int value: 4 bytes
                         // - 패딩: 가변

int[] primitives = new int[1000];        // ~4KB
Integer[] wrappers = new Integer[1000];  // ~20KB+ (객체 배열 + 각 Integer 객체)

// 비효율적인 코드
Long sum = 0L;
for (long i = 0; i < 1_000_000; i++) {
    sum += i;  // 매 반복마다 unboxing → 연산 → boxing
}

// 효율적인 코드
long sum = 0L;
for (long i = 0; i < 1_000_000; i++) {
    sum += i;  // primitive 연산만
}

// 나쁜 예: 불필요한 객체 생성
for (int i = 0; i < 1_000_000; i++) {
    Integer temp = i * 2;  // 매번 새 객체 생성 (캐시 범위 벗어나면)
    // ...
}

// Good: primitive 사용
public int calculateSum(int[] numbers) {
    int sum = 0;  // primitive
    for (int num : numbers) {
        sum += num;
    }
    return sum;
}

// Good: 필요한 경우에만 Wrapper
public class User {
    private long id;              // not null, primitive
    private Integer age;          // nullable, wrapper
    private boolean active;       // not null, primitive
}

// Good: 비교는 equals() 사용
public boolean isSameValue(Integer a, Integer b) {
    return Objects.equals(a, b);  // null-safe
}

// 미래의 Java (예상)
primitive class Point {
    int x;
    int y;
}
// 객체처럼 사용하지만 primitive처럼 효율적