1
2
3
4
5
6
7
8
9
10
// Java 9+ (Compact Strings)
public final class String implements Serializable, Comparable<String>, CharSequence {
    @Stable
    private final byte[] value;    // 문자열 데이터 (final!)
    private final byte coder;      // LATIN1(0) 또는 UTF16(1)
    private int hash;              // hashCode 캐시 (지연 계산)
    private boolean hashIsZero;    // hash가 0인 것이 실제 0인지 미계산인지 구분

    // Java 8 이전: private final char[] value;
}

1
2
3
4
5
String s = "Hello";
s.toUpperCase();    // "HELLO"을 반환하지만
System.out.println(s);  // "Hello" — 원본은 변경되지 않음!

String upper = s.toUpperCase();  // 새 String 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// String.hashCode() — 한 번 계산하면 캐싱
public int hashCode() {
    int h = hash;
    if (h == 0 && !hashIsZero) {
        h = isLatin1() ? StringLatin1.hashCode(value)
                       : StringUTF16.hashCode(value);
        if (h == 0) {
            hashIsZero = true;
        } else {
            hash = h;
        }
    }
    return h;
}

1
2
3
4
5
6
7
8
9
String s1 = "Hello";                    // String Pool에 생성
String s2 = "Hello";                    // Pool에서 같은 참조 반환
String s3 = new String("Hello");        // Heap에 새 객체 생성
String s4 = new String("Hello").intern(); // Pool에서 참조 반환

System.out.println(s1 == s2);       // true  (같은 Pool 참조)
System.out.println(s1 == s3);       // false (Pool vs Heap)
System.out.println(s1 == s4);       // true  (intern()이 Pool 참조 반환)
System.out.println(s1.equals(s3));  // true  (내용 비교)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// String: 불변, 문자열 연결 시 새 객체 생성
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i;  // 매 반복마다 새 String + StringBuilder 생성
}
// → O(n²) 시간 복잡도!

// StringBuilder: 가변, 단일 스레드 환경
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);  // 내부 버퍼에 추가
}
String result = sb.toString();
// → O(n) 시간 복잡도

// StringBuffer: 가변, 멀티 스레드 안전 (synchronized)
StringBuffer sbuf = new StringBuffer();  // 모든 메서드가 synchronized

1
2
3
4
5
6
7
8
// == : 참조(주소) 비교
// equals() : 내용(논리적 동등성) 비교

String a = new String("Hello");
String b = new String("Hello");

a == b        // false — 서로 다른 객체
a.equals(b)   // true  — 내용이 같음

1
2
3
4
// Object.java
public boolean equals(Object obj) {
    return (this == obj);  // 기본: 참조 비교 (== 와 동일!)
}

1
2
3
4
5
6
7
// Effective Java Item 10의 규약

// 1. 반사성 (Reflexivity): x.equals(x) == true
// 2. 대칭성 (Symmetry): x.equals(y) == true → y.equals(x) == true
// 3. 추이성 (Transitivity): x.equals(y) && y.equals(z) → x.equals(z)
// 4. 일관성 (Consistency): 같은 인수로 여러 번 호출해도 항상 같은 결과
// 5. null 비동등성: x.equals(null) == false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 잘못된 구현: 대칭성 위반
public class CaseInsensitiveString {
    private final String s;

    @Override
    public boolean equals(Object o) {
        if (o instanceof CaseInsensitiveString)
            return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
        if (o instanceof String)  // 문제!
            return s.equalsIgnoreCase((String) o);
        return false;
    }
}

CaseInsensitiveString cis = new CaseInsensitiveString("Hello");
String s = "hello";

cis.equals(s)  // true — CaseInsensitiveString이 String과 비교
s.equals(cis)  // false — String은 CaseInsensitiveString을 모름
// → 대칭성 위반!

1
2
3
// Object.java
public native int hashCode();
// 기본: 메모리 주소 기반 (구현체마다 다름)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class User {
    private final Long id;
    private final String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(id, user.id);
    }

    // hashCode() 오버라이드 안 함!
}

// 문제 발생:
User user1 = new User(1L, "홍길동");
User user2 = new User(1L, "홍길동");

user1.equals(user2);  // true — equals 오버라이드했으므로

// HashMap에서의 동작
Map<User, String> map = new HashMap<>();
map.put(user1, "데이터");
map.get(user2);  // null!! — user2로 꺼낼 수 없다

// 왜?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class User {
    private final Long id;
    private final String name;
    private final String email;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                    // 반사성 + 성능
        if (!(o instanceof User user)) return false;   // 타입 체크 + null 체크
        return Objects.equals(id, user.id);            // 비즈니스 키 비교
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);  // equals에서 사용한 필드와 동일!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// 잘못된 방법: @GeneratedValue ID 사용
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Order)) return false;
        return Objects.equals(id, ((Order) o).id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

// 문제:
Order order = new Order();       // id = null (아직 persist 전)
Set<Order> set = new HashSet<>();
set.add(order);                  // hashCode = Objects.hash(null) = 0
entityManager.persist(order);    // id = 1L로 변경
set.contains(order);             // false! hashCode가 바뀜 → Set에서 찾을 수 없음

// 올바른 방법 1: 비즈니스 키 사용
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;

    @Column(unique = true)
    private String orderNumber;  // 비즈니스 키

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Order)) return false;
        return Objects.equals(orderNumber, ((Order) o).orderNumber);
    }

    @Override
    public int hashCode() {
        return Objects.hash(orderNumber);
    }
}

// 올바른 방법 2: 고정 hashCode
@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Order order)) return false;
        return id != null && Objects.equals(id, order.id);
    }

    @Override
    public int hashCode() {
        return getClass().hashCode();  // 모든 인스턴스가 같은 해시 → 성능↓ 정확성↑
    }
}

1
2
3
4
5
6
7
8
9
10
11
// 제네릭 이전 (Java 5 미만)
List list = new ArrayList();
list.add("Hello");
list.add(123);          // 컴파일 에러 없음!
String s = (String) list.get(1);  // 런타임 ClassCastException!

// 제네릭 이후
List<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123);       // 컴파일 에러! 타입 안전성 보장
String s = list.get(0); // 캐스팅 불필요

1
2
3
4
5
6
7
8
9
// 소스 코드
List<String> strings = new ArrayList<>();
strings.add("Hello");
String s = strings.get(0);

// 컴파일 후 바이트코드 (타입 소거)
List strings = new ArrayList();     // <String> 제거됨
strings.add("Hello");
String s = (String) strings.get(0); // 컴파일러가 캐스트 삽입

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 1. instanceof에 제네릭 타입을 사용할 수 없다
if (list instanceof List<String>) { }  // 컴파일 에러!
if (list instanceof List<?>) { }       // OK (비한정 와일드카드만 가능)

// 2. 제네릭 타입으로 배열을 생성할 수 없다
T[] array = new T[10];                 // 컴파일 에러!
List<String>[] array = new List<String>[10]; // 컴파일 에러!

// 3. 런타임에 제네릭 타입 정보를 알 수 없다
List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
strings.getClass() == integers.getClass();  // true! (둘 다 ArrayList.class)

// 4. 제네릭 타입의 static 필드 불가
public class Box<T> {
    private static T value;  // 컴파일 에러!
    // Box<String>과 Box<Integer>가 같은 클래스이므로
    // static T가 String인지 Integer인지 결정 불가
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 비한정 와일드카드: ?
// "모든 타입"을 받을 수 있지만, 꺼낼 때 Object로만 받음
public void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
    // list.add("Hello");  // 컴파일 에러! (null만 가능)
}

// 상한 경계 와일드카드: ? extends T
// T와 T의 하위 타입만 허용, 읽기만 가능 (Producer)
public double sumOfList(List<? extends Number> list) {
    double sum = 0;
    for (Number n : list) {  // Number로 읽기 가능
        sum += n.doubleValue();
    }
    // list.add(1);  // 컴파일 에러! 정확한 타입을 모르므로 쓰기 불가
    return sum;
}

// 하한 경계 와일드카드: ? super T
// T와 T의 상위 타입만 허용, 쓰기 가능 (Consumer)
public void addNumbers(List<? super Integer> list) {
    list.add(1);       // Integer를 넣을 수 있음
    list.add(2);
    // Integer n = list.get(0);  // 컴파일 에러! 꺼낼 때 Object로만 받음
    Object o = list.get(0);      // Object로만 가능
}

1
2
3
4
5
6
7
8
9
10
11
12
// Collections.copy() — PECS의 교과서적 예시
public static <T> void copy(List<? super T> dest,    // Consumer: 데이터를 넣음
                              List<? extends T> src) { // Producer: 데이터를 꺼냄
    for (int i = 0; i < src.size(); i++) {
        dest.set(i, src.get(i));  // src에서 꺼내서(extends) dest에 넣음(super)
    }
}

// 사용 예시
List<Integer> ints = List.of(1, 2, 3);
List<Number> nums = new ArrayList<>(List.of(0, 0, 0));
Collections.copy(nums, ints);  // Integer는 Number의 하위 타입 → OK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 이 둘은 동작이 같지만, 어떤 것을 써야 하나?

// 제네릭 메서드
public <T> void swap(List<T> list, int i, int j) {
    T temp = list.get(i);
    list.set(i, list.get(j));
    list.set(j, temp);
}

// 와일드카드
public void swap(List<?> list, int i, int j) {
    // list.set(i, list.get(j));  // 컴파일 에러! ?는 쓰기 불가
    swapHelper(list, i, j);       // 헬퍼 메서드 필요
}
private <T> void swapHelper(List<T> list, int i, int j) {
    T temp = list.get(i);
    list.set(i, list.get(j));
    list.set(j, temp);
}

1
2
3
4
5
6
7
8
9
10
// Autoboxing: int → Integer
Integer a = 42;         // 컴파일러: Integer a = Integer.valueOf(42);

// Unboxing: Integer → int
int b = a;              // 컴파일러: int b = a.intValue();

// 연산 시
Integer x = 10;
Integer y = 20;
int sum = x + y;        // 컴파일러: int sum = x.intValue() + y.intValue();

1
2
3
4
5
6
7
8
9
Integer a = 127;
Integer b = 127;
System.out.println(a == b);   // true (!!)

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

// 왜?

1
2
3
4
5
6
7
8
9
10
11
12
// 따라서 Integer 비교는 항상 equals()를 사용해야 한다
Integer a = 128;
Integer b = 128;
a == b           // false (서로 다른 객체)
a.equals(b)      // true  (내용 비교)
Objects.equals(a, b)  // true (null-safe)

// 다른 래퍼 타입의 캐시 범위
// Byte, Short, Integer, Long: -128 ~ 127
// Character: 0 ~ 127
// Boolean: TRUE, FALSE (항상 캐시)
// Float, Double: 캐시 없음

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Integer value = null;
int result = value;   // NullPointerException!
// 컴파일러: int result = value.intValue(); → NPE

// 실무에서 흔한 실수
public int getAge(User user) {
    return user.getAge();  // getAge()가 Integer를 반환하면?
    // user.age가 null이면 NPE!
}

// 안전한 방법
public int getAge(User user) {
    Integer age = user.getAge();
    return age != null ? age : 0;
    // 또는
    return Optional.ofNullable(user.getAge()).orElse(0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 끔찍한 성능의 코드
Long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;  // 매 반복마다 Autoboxing + Unboxing!
    // 컴파일러: sum = Long.valueOf(sum.longValue() + i);
    // → 약 2^31개의 Long 객체 생성!
}

// 올바른 코드
long sum = 0L;  // primitive 사용
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;  // 박싱 없음
}
// → 약 6배 빠름

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 제네릭은 기본 타입을 사용할 수 없다
List<int> list;      // 컴파일 에러!
List<Integer> list;  // OK — 래퍼 타입만 가능

// 이것이 Stream에 IntStream, LongStream이 존재하는 이유
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

// 느림: 매번 unboxing
int sum1 = list.stream()
    .reduce(0, Integer::sum);  // Integer → int 반복

// 빠름: primitive 전용 스트림
int sum2 = list.stream()
    .mapToInt(Integer::intValue)  // IntStream으로 변환
    .sum();                        // primitive 연산

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 1. final 변수: 재할당 불가
final int x = 10;
// x = 20;  // 컴파일 에러

// 2. final 메서드: 오버라이드 불가
public class Parent {
    public final void method() { }
}
public class Child extends Parent {
    // public void method() { }  // 컴파일 에러
}

// 3. final 클래스: 상속 불가
public final class String { }
// public class MyString extends String { }  // 컴파일 에러

1
2
3
4
5
6
final List<String> list = new ArrayList<>();
list.add("Hello");    // OK! — 리스트 내용 수정 가능
list.add("World");    // OK!
// list = new ArrayList<>();  // 컴파일 에러! — 참조 변경 불가

// final은 "참조"를 고정하는 것이지, "객체"를 불변으로 만드는 것이 아니다!

1
2
3
4
5
// Java 8+: 변수가 사실상(effectively) final이면 lambda에서 사용 가능
String name = "Hello";  // final 선언 안 했지만 재할당 안 함
// name = "World";      // 이 줄이 있으면 아래 lambda 컴파일 에러

Runnable r = () -> System.out.println(name);  // OK (effectively final)

1
2
3
4
5
6
7
8
9
10
11
public class SafePublication {
    private final int value;
    private final List<String> list;

    public SafePublication(int value) {
        this.value = value;
        this.list = List.of("a", "b", "c");
        // 생성자 완료 후, 다른 스레드에서 value와 list가
        // 올바른 값으로 보인다 (JMM final 필드 의미론)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 이 enum은...
public enum Color {
    RED, GREEN, BLUE;
}

// 사실 이것과 같다 (컴파일러가 생성)
public final class Color extends Enum<Color> {
    public static final Color RED = new Color("RED", 0);
    public static final Color GREEN = new Color("GREEN", 1);
    public static final Color BLUE = new Color("BLUE", 2);

    private static final Color[] $VALUES = { RED, GREEN, BLUE };

    private Color(String name, int ordinal) {
        super(name, ordinal);
    }

    public static Color[] values() {
        return $VALUES.clone();
    }

    public static Color valueOf(String name) {
        return Enum.valueOf(Color.class, name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public enum Singleton {
    INSTANCE;

    private final Connection connection;

    Singleton() {
        connection = createConnection();
    }

    public Connection getConnection() {
        return connection;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Color c1 = Color.RED;
Color c2 = Color.RED;

c1 == c2       // true (항상! 같은 상수 인스턴스)
c1.equals(c2)  // true

// Enum은 ==와 equals() 결과가 항상 같다
// Enum.equals()가 ==로 구현되어 있기 때문
public final boolean equals(Object other) {
    return this == other;
}

// 따라서 Enum 비교에는 ==을 사용하는 것이 더 좋다
// → null-safe: null == Color.RED → false (NPE 없음)
// → null.equals(Color.RED) → NPE!