불변 객체는 공유해도 안전하기 때문에 동기화(synchronization) 없이 사용할 수 있다.
가변 객체(Mutable Object)는 여러 스레드에서 동시에 수정하면서 데이터 불일치 문제가 생길 수 있다.
Integer x = 100;
Integer y = x; // x와 y가 같은 객체를 참조
x = x + 1; // 새로운 Integer 객체가 생성됨 (기존 객체 변경 없음)
System.out.println(y); // 여전히 100 (안전!)
System.out.println(x); // 101 (새 객체 생성)
2. 해싱 최적화
해시 기반 자료구조(HashMap, HashSet 등)에서 키로 사용할 때 안정적이다.
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
Integer key = 100; // Integer는 불변 객체!
map.put(key, "Hello");
System.out.println(map.get(key)); // Hello
// key의 값은 변하지 않으므로, 해시 값도 그대로 유지됨
System.out.println(key.hashCode()); // 항상 100 출력
}
}
불변 객체의 단점
값이 변경될 때 새로운 객체를 계속 생성해야 하기 때문에, 메모리를 더 많이 사용한다.
하지만, 자바는 캐싱을 통해 불필요한 객체 생성을 줄이고 있다.
캐싱을 통한 불필요한 객체 생성 방지
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true (같은 객체를 재사용)
Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false (새 객체 생성)
자바에서는 Integer 객체를 매번 새로 생성하면 메모리를 많이 낭비할 수 있어서, 자주 사용되는 숫자 범위(-128~127)는 미리 캐싱해서 재사용하도록 설계되어 있다.
자바 8부터는 JVM 옵션(-XX:AutoBoxCacheMax=<값>)을 통해 캐싱 범위를 변경할 수 있다.
그렇다면 내부적으로 어떻게 같은 값이라는 걸 알고 기존 객체를 재활용하는 걸까?
캐싱 동작 탐구
Step 1
`Integer.valueOf(int)`로 객체화된 값을 저장
Integer a = 127; // 내부적으로 Integer.valueOf(127) 호출
Integer b = 127; // 동일한 Integer 객체를 재사용
System.out.println(a == b); // true (같은 객체)
Step 2
`Integer.valueOf(int)` 내부 코드를 보면, 값이 -128~127인 경우는 IntegerCache 클래스를 호출하고, 그 외는 새로운 객체 생성
public static Integer valueOf(int i) {
if (i >= -128 && i <= 127) { // 캐싱 범위 확인
return IntegerCache.cache[i + 128]; // 기존 객체 반환
}
return new Integer(i); // 범위 밖이면 새로운 객체 생성
}
Step 3
Integer 클래스의 내부 클래스인 IntegerCache 클래스를 보면, -128~127의 객체를 모두 생성해둔다.
private static class IntegerCache {
static final Integer cache[];
static {
cache = new Integer[256]; // -128 ~ 127 저장
for (int i = 0; i < cache.length; i++) {
cache[i] = new Integer(i - 128); // 미리 Integer 객체 생성
}
}
}
결론적으로, 이미 Integer 클래스가 로드될 때 static 블록으로 인해 -128~127의 객체를 바로 생성해두고, 필요 시 해당 객체를 반환하는 형식으로 캐싱이 이루어진다.
그렇다면 -128~127의 수를 모두 객체화 해두는 건 비효율적이지 않을까?
-128 ~ 127 범위는 자주 사용되는 숫자들이라 캐싱해두면 오히려 성능에 좋음
루프 변수 (for (int i = 0; i < 100; i++))
배열 인덱스, 개수(size, length)
흔한 숫자(0, 1, -1, 100 등)
캐싱된 객체가 차지하는 메모리가 크지 않음
IntegerCache는 256개의 Integer 객체(-128 ~ 127)를 미리 생성하는데,
Integer 객체 1개 ≈ 16바이트 (객체 헤더 + 필드)
256개 × 16바이트 ≈ 4KB 정도의 메모리 사용
✅ 1️⃣ 캐싱이 적용되는 클래스
Integer, Short, Byte, Long, Character → 작은 범위의 정수를 캐싱
Boolean → true, false 두 개만 존재하므로 항상 같은 객체 사용
String → String Pool을 사용하여 리터럴 문자열 재사용
new String("hello")로 생성하면 새로운 객체 참조
.intern()을 호출하면 스트링 풀에 있는 "hello"와 동일한 객체를 참조
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s1 == s2); // true (같은 객체)
System.out.println(s3 == s4); // false (다른 객체)
System.out.println(s1 == s3); // false (다른 객체)
String str1 = "hello";
String str2 = new String("hello").intern(); // intern() 메서드로 동일한 객체 탐색 후 참조
String str3 = str1.intern(); // 이렇게도 사용 가능
System.out.println(str1 == str2); // true
❌ 2️⃣ 캐싱이 없는 클래스
Double, Float → 실수값이 무한대에 가깝고, 자주 같은 값을 쓸 일이 적음
BigInteger, BigDecimal → 숫자의 범위가 너무 커서 캐싱하면 메모리 낭비가 심함
class MyClass {
static {
System.out.println("클래스가 로드될 때 한 번만 실행됩니다.");
}
}
public class Main {
public static void main(String[] args) {
new MyClass(); // MyClass가 메모리에 로드될 때 static 블록 실행
new MyClass(); // static 블록 실행 안 함
new MyClass(); // static 블록 실행 안 함
}
}
☝️ 위 코드에서 MyClass 객체를 여러 번 생성해도, 문장은 처음 객체를 생성했을 때만 출력된다. 프로그램을 종료하게 되면 JVM이 메모리를 비우고, 재실행될 때 JVM이 다시 메모리에 클래스를 로드하기 때문에 static 블록은 다시 실행하게 된다.
static 클래스
클래스 안에 선언된 클래스(=내부 클래스)만 static 클래스로 지정이 가능하다.
외부 클래스의 인스턴스를 생성하지 않아도 바로 내부 클래스를 사용할 수 있다.
class Outer {
static class Inner {
void display() {
System.out.println("Static 내부 클래스입니다!");
}
}
}
public class Main {
public static void main(String[] args) {
Outer.Inner obj = new Outer.Inner(); // 바깥 클래스 없이 바로 사용 가능!
obj.display();
}
}
☝️ 내부 클래스가 static 클래스가 아니었다면, 내부 클래스를 사용할 때 `new Outer().new Inner();` 와 같은 코드를 작성해야 한다.
// Map.Entry가 대표 예시인데 이해 안 됨! -> Map 공부하고 다시 보기
일반 내부 클래스 vs 정적 내부 클래스
내부 클래스 유형
바깥 클래스 속성 접근 가능 여부
일반 내부 클래스 (static 없음)
✅ 바깥 클래스의 모든 멤버(private 포함)에 접근 가능
정적 내부 클래스 (static 있음)
❌ 바깥 클래스의 인스턴스 변수에는 직접 접근 불가 (객체를 전달해야 함)
일반 내부 클래스는 바깥 클래스의 일부분으로 포함되어 있는 클래스이기 때문에, 바깥 클래스의 private 멤버에도 접근이 가능하다.
정적 내부 클래스는 static이 아닌 동적인 멤버에는 직접적으로 접근할 수 없다.
따라서 접근하기 위해서는 개별적인 클래스처럼 바깥 클래스의 객체를 생성하고 객체를 정적 내부 클래스에 전달해주어야 한다.
클래스의 로딩 시점
클래스의 객체 생성 시
정적 메서드, 정적 변수에 처음 접근할 때
class Counter {
static int count = 0; // 클래스 변수
static {
System.out.println("Counter 클래스가 로딩되었습니다.");
}
void increment() {
count++;
}
}
public class Main {
public static void main(String[] args) {
// 클래스가 처음 사용될 때 로딩됨
System.out.println(Counter.count); // 클래스 변수에 접근
Counter c1 = new Counter(); // 클래스의 인스턴스를 생성
c1.increment();
System.out.println(Counter.count); // 클래스 변수에 접근
}
}
Counter 클래스가 로딩되었습니다. //static 블록으로 인해 처음 로드될 때 한 번 실행됨
0
1
클래스 로딩 방식
자바는 클래스를 지연 로딩(Lazy Loading)방식으로 로딩한다.
즉, 모든 클래스를 프로그램을 실행하자마자 로딩하는 방식이 아니라, 해당 클래스가 참조되는 순간 메모리에 로드되는 것이다.
그 이후는 해당 클래스가 여러 번 참조되더라도 프로그램을 재실행하지 않는 이상 다시 로딩하지 않는다.
한 번 로드된 클래스는 메모리 캐시에 유지되어 프로그램이 종료되기 전까지 꺼내어 사용할 수 있기 때문이다.
정적 메서드, 정적 변수는 로드될 때 method area에 저장되기 때문에 모든 객체가 데이터를 공유하며 상시 접근이 가능하다.
그러나 method area에 동적 데이터에 대한 정보는 선언된 틀만 존재하고, 데이터를 할당할 공간 자체가 없다.
힙에 각 객체의 동적 데이터를 저장함으로써 모든 객체는 동일한 틀을 가지면서도 각기 다른 값을 저장할 수 있는 것이다.
이러한 이유로 static이 아닌, 동적 데이터는 객체가 생성되어 힙에 저장된 순간부터 접근할 수 있다.
입력값이 정답에 포함된 알파벳일 경우 해당 알파벳이 들어간 자리를 전부 보여주고, 다시 입력을 받습니다.
ex ) 정답이 eyes 인 경우에 E 를 입력했을 때
_ _ _ _ → E _ E _
입력값이 정답에 포함되지 않은 알파벳일 경우 기회가 하나 차감되고, 다시 입력을 받습니다.
사용자가 9번 틀리면 게임오버됩니다.
게임오버 되기 전에 영어단어의 모든 자리를 알아내면 플레이어의 승리입니다.
알고리즘 설계
영단어 목록을 String 타입 배열 `words`에 저장
Random()을 사용해서 임의의 영단어 하나를 String 타입 변수 `correctWord`에 저장
length()로 문자열의 길이를 구해서 길이만큼 언더바 출력
반복문
`inputLetter`가 2글자 이상 입력인 경우 try-catch문으로 예외 처리
try -> Scanner로 char 타입 문자 입력받아서 char 타입 변수 `inputLetter`에 저장
catch -> 잘못된 입력 안내 후 continue
조건문
Charactor.isLetter()로 알파벳 입력인지 확인 후 알파벳이 아니면 continue
`inputLetterLog`에 이미 존재하는 문자인지 반복하면서 확인 후, 이미 존재하면 continue
else -> char 타입 배열 `inputLetterLog`에 저장
`correctWord`와 `inputLetter`을 charAt으로 반복하면서 확인
동일한 문자가 있는 위치는 해당 문자 출력 / 그 외의 문자는 언더바 출력
동일한 문자가 없으면 count++
count가 9인 경우 Game Over 출력 후 break
변경 사항
1. Scanner 객체는 char 타입으로 입력 ❌
`scanner.next().charAt(0)`으로 코드를 작성하면 문자열로 입력받아도 결과적으로 한 글자만 입력받은 것처럼 사용할 수 있다.
하지만 문제 자체가 한 글자가 아닌 경우 다시 입력받도록 하는 시스템이기 때문에, 문자열로 입력받고 조건문을 추가해야겠다.
2. inputLetterLog에 이미 존재하는 문자인지 확인 후 continue 대신 flag 사용
문자를 맞히기 위한 반복문 안에서 inputLetter와 inputLetterLog를 순서대로 비교하는 반복문을 중첩으로 사용했다.
중첩된 반복문 안에서 continue를 사용하면 inputLetterLog의 다음 인덱스로 넘어가는 로직이 되기 때문에, 내 의도대로 다음 입력을 받기 위한 continue가 될 수 없다.
따라서 inputLetterLog와 inputLetter의 데이터 중복 여부를 알 수 있는 flag를 만들고, 이 flag값을 조건으로 줘서 입력값을 inputLetterLog에 저장하도록 수정하자.
3. 시도 횟수를 나타내는 count 변수를 반복을 진행하면서 증가시키는 대신 감소시키기
처음 초기화할 때 가능한 시도 횟수를 지정해주는 게, 추후 시도 횟수를 변경하는 상황에서 수정이 편리할 것 같다.
4. underBarCnt , letterCnt 변수 추가
`correctWord`의 어떤 위치에도 `inputLetter`값이 없는 상황을 판단하기 위해
`correctWord`와 `inputLetter`을 charAt으로 반복하는 과정에서, 언더바를 출력할 때 변수 `underBarCnt`를 증가시킨다.
그리고 `correctWord`의 문자열 길이와 `underBarCnt`가 같으면 시도 횟수를 증가시킨다.
정답을 맞힌 경우 시스템을 종료하기 위해
`correctWord`와 `inputLetter`을 charAt으로 반복하는 과정에서, 문자를 출력할 때 변수 `letterCnt`를 증가시킨다.
5. count 변수명을 tryCount로 변경
underBarCnt와의 혼동 방지
6. 정답을 맞힌 경우 시스템을 종료하는 코드 추가
모든 인덱스의 문자를 맞혀도 계속 진행되는 논리적 오류 발생
추가한 `letterCnt` 변수의 값이 정답 문자열의 길이와 같으면 종료하는 코드를 추가하자
최종 실행 과정
1. 영단어 목록을 String 타입 배열 `words`에 저장
2. Random()을 사용해서 임의의 영단어 하나를 String 타입 변수 `correctWord`에 저장
Random random = new Random();
String correctWord = words[random.nextInt(15)];
3. length()로 문자열의 길이를 구해서 길이만큼 언더바 출력
for (int i = 0; i < correctWord.length(); i++) {
System.out.print("_");
}
4. 반복문
조건문
`inputLetter`가 2글자 이상 입력인 경우 continue
Charactor.isLetter()로 알파벳 입력인지 확인 후 알파벳이 아니면 continue
`inputLetterLog`에 이미 존재하는 문자인지 반복하면서 확인 후, 이미 존재하면 디폴트가 false였던 `isDuplicate` 변수를 true로 변경
`isDuplicate`가 false인 상황에서만 `inputLetterLog`에 입력값 저장
String inputLetter = scanner.next();
// 입력값이 한 글자가 아니면 다시 입력
if (inputLetter.length() != 1) {
continue;
}
// 입력값이 알파벳이 아니면 다시 입력
if (!Character.isLetter(inputLetter.charAt(0))) {
continue;
}
boolean isDuplicate = false;
// 입력값이 inputLetterLog에 있는지 확인
for (String string : inputLetterLog) {
if (string.equals(inputLetter)) {
isDuplicate = true;
}
}
// 이전에 입력하지 않은 값만 저장
if(!isDuplicate){
inputLetterLog.add(inputLetter);
}
`correctWord`와 `inputLetter`을 charAt으로 반복하면서 확인
동일한 문자가 있는 위치는 해당 문자 출력
그 외의 문자는 언더바 출력 후 underBarCnt++
`correctWord`의 길이와 `underBarCnt`가 같으면(어떤 위치에도 입력한 문자가 없으면) tryCount--
// tryCount가 0인 경우 Game Over
if(tryCount==0){
System.out.println("\nGame over!");
break;
}
`letterCnt`가 `correctWord`의 길이와 값이 같은 경우 "You are win"과 `correctWord` 출력 후 break
// correctWord의 모든 인덱스를 맞힌 경우 시스템 종료
if(correctWord.length()==letterCnt){
System.out.println("\n" + correctWord);
System.out.println("You are win!");
break;
}
결과
☝️ if문 조건식의 반환값이 boolean인 경우 값이 true면 `!true`가 돼서 실행 X 값이 false면 `!false`, 즉 `true`가 돼서 실행 O
☝️ Character.isLetter(char) 값이 문자면 true 문자가 아니면 false 반환
// for문
public class Main {
public static void main(String[] args) {
// ArrayList 선언
List<Integer> arrayList = new ArrayList<>(List.of(1, 2, 3, 4, 5));
// ✅ for 명령형 스타일: 각 요소 * 10 처리
List<Integer> ret1 = new ArrayList<>();
for (Integer num : arrayList) {
int multipliedNum = num * 10; // 각 요소 * 10
ret1.add(multipliedNum);
}
System.out.println("ret1 = " + ret1);
}
}
// 스트림
public class Main {
public static void main(String[] args) {
// ArrayList 선언
List<Integer> arrayList = new ArrayList<>(List.of(1, 2, 3, 4, 5));
// ✅ 스트림 선언적 스타일: 각 요소 * 10 처리
List<Integer> ret2 = arrayList.stream()
.map(num -> num * 10)
.collect(Collectors.toList());
System.out.println("ret2 = " + ret2);
}
}
☝️ ArrayList를 List 인터페이스로 받는 이유
List 인터페이스로 구현체(ArrayList)를 받으면 나중에 다른 구현체(LinkedList, Vector) 로 변경할 때 코드 수정을 최소화
아래 코드는 인터페이스 객체를 생성하는 것이 아니라, 인터페이스를 구현한 익명 클래스의 객체를 생성
public interface Calculator {
int sum(int a, int b);
}
public class Main {
public static void main(String[] args) {
// ✅ 익명 클래스 활용
Calculator calculator1 = new Calculator() {
@Override
public int sum(int a, int b) {
return a + b;
}
};
int ret1 = calculator1.sum(1, 1);
System.out.println("ret1 = " + ret1);
}
}
