[java-mid1] 4. 래퍼, Class 클래스

"김영한의 실전 자바 - 중급편" 내용을 참고하여 정리함.

목차

 

1. 래퍼 클래스 - 기본형의 한계1

기본형의 한계

자바는 객체 지향 언어이지만 `int`, `double` 과 같은 기본형(Primitive Type)은 객체가 아니다.
기본형이 객체가 아닐 때의 주요 한계는 다음과 같다.

1. 객체가 아님
   • 기본형은 메서드를 가질 수 없으며, 객체 지향의 장점을 활용할 수 없다.
   • 객체가 필요한 컬렉션 프레임워크(List, Set, Map 등)와 제네릭을 사용할 수 없다.
2. null 값을 가질 수 없음
   • 기본형은 항상 값을 가져야 하며 `null` 을 가질 수 없다.
   • 데이터가 '없음'을 나타내야 할 경우에도 `-1`, `0` 등의 특별한 값을 사용해야 한다.

 

예제: 기본형을 비교하는 외부 메서드 사용

기본형인 `int` 값을 비교할 때는 외부 메서드를 사용해야 한다.

public class MyIntegerMethodMain {
    public static void main(String[] args) {
        int value = 10;
        System.out.println(compareTo(value, 5));  // 1
        System.out.println(compareTo(value, 10)); // 0
        System.out.println(compareTo(value, 20)); // -1
    }

    public static int compareTo(int value, int target) {
        if (value < target) return -1;
        if (value > target) return 1;
        return 0;
    }
}

이 방식은 `value` 가 자기 자신의 값을 직접 비교하는 것이 아니라 외부 메서드를 이용해야 한다는 단점이 있다.

 

예제: 직접 래퍼 클래스 만들기

기본형의 한계를 극복하기 위해 `int` 값을 감싸는 래퍼 클래스이다.

public class MyInteger {
    private final int value;

    public MyInteger(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public int compareTo(int target) {
        if (value < target) return -1;
        if (value > target) return 1;
        return 0;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

• 예제1의 `compareTo()` 메서드를 클래스 내부로 캡슐화 했다. (인스턴스에 소속된 메서드로 변경)
• 이 클래스는 불변으로 설계되었다.
• 이제 객체를 통해 값을 비교할 수 있다.

 

public class MyIntegerMethodMain {
    public static void main(String[] args) {
        MyInteger myInteger = new MyInteger(10);
        System.out.println(myInteger.compareTo(5));  // 1
        System.out.println(myInteger.compareTo(10)); // 0
        System.out.println(myInteger.compareTo(20)); // -1
    }
}

• `int` 를 `MyInteger` 를 통해 객체로 다룰 수 있게 되었다.
• 기본형을 감싼 객체를 사용함으로써 객체의 메서드를 호출하는 방식으로 비교할 수 있게 되었다.

 

 

2. 래퍼 클래스 - 기본형의 한계2

기본형과 null

기본형은 항상 값을 가져야 하며, null을 가질 수 없다.

하지만 때로는 값이 존재하지 않는 상태를 표현해야 하는 경우가 있다.

 

예제: 기본형을 반환하는 경우, 값이 없음을 표현하기 어려움

public class MyIntegerNullMain {
    public static void main(String[] args) {
        int[] intArr = {-1, 0, 1, 2, 3};
        System.out.println(findValue(intArr, -1)); // -1
        System.out.println(findValue(intArr, 100)); // -1 (값이 없는 경우도 -1)
    }

    private static int findValue(int[] intArr, int target) {
        for (int value : intArr) {
            if (value == target) return value;
        }
        return -1; // 값이 없을 때도 -1을 반환
    }
}

• 문제점: -1이 실제 데이터인지, 값이 없는 상태를 의미하는지 구분할 수 없다.

 

예제: 래퍼 클래스를 사용하여 null을 활용하기

public class MyIntegerNullMain {
    public static void main(String[] args) {
        MyInteger[] intArr = {new MyInteger(-1), new MyInteger(0), new MyInteger(1)};
        System.out.println(findValue(intArr, -1)); // -1
        System.out.println(findValue(intArr, 100)); // null
    }

    private static MyInteger findValue(MyInteger[] intArr, int target) {
        for (MyInteger myInteger : intArr) {
            if (myInteger.getValue() == target) return myInteger;
        }
        return null; // 값이 없을 경우 null 반환
    }
}

• 객체인 참조형은 값 이 없다는 `null` 을 사용할 수 있다.
• 이제 값이 없으면 `null` 을 반환할 수 있어 `-1`과 같은 애매한 값을 사용할 필요가 없다.
• `null` 값을 반환하는 경우 잘못하면 `NullPointerException` 이 발생할 수 있기 때문에 주의해서 사용해야 한다.

 

 

3. 래퍼 클래스 - 자바 래퍼 클래스

자바는 기본형을 객체로 감싸는 래퍼 클래스를 제공한다. 래퍼 클래스는 기본형의 객체 버전이다.

기본형	래퍼 클래스
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

 

래퍼 클래스의 특징

• 불변이다.
• `equals` 로 비교해야 한다.

 

박싱(Boxing)과 언박싱(Unboxing)

1. 박싱(Boxing) - 래퍼 클래스 생성

Integer integerObj = Integer.valueOf(10);

• 기본형을 래퍼 클래스로 변경하는 것.
• `new Integer(10)` 은 직접 사용하면 안된다. 작동은 하지만, 향후 자바에서 제거될 예정이다.
• `Integer.valueOf()` 에는 성능 최적화 기능이 있다. -128 ~ 127 범위의 `Integer` 클래스를 미리 생성한다.
  • 문자열 풀과 비슷하게 자주 사용하는 숫자를 미리 생성해두고 재사용한다.

 

2. 언박싱(UnBoxing)

int intValue = integerObj.intValue();

• 래퍼 클래스에서 기본형 값을 꺼내는 것.

 

예제: 기본형과 래퍼 클래스 변환

public class WrapperClassMain {
    public static void main(String[] args) {
        // 박싱(Boxing) - 기본형을 래퍼 클래스로 변환
        Integer integerObj = Integer.valueOf(10);
        Long longObj = Long.valueOf(100);
        Double doubleObj = Double.valueOf(10.5);

        System.out.println("integerObj = " + integerObj);
        System.out.println("longObj = " + longObj);
        System.out.println("doubleObj = " + doubleObj);

        // 언박싱(Unboxing) - 래퍼 클래스에서 기본형 값 가져오기
        int intValue = integerObj.intValue();
        long longValue = longObj.longValue();

        System.out.println("intValue = " + intValue);
        System.out.println("longValue = " + longValue);

        // 값 비교 (주의: == 연산자와 equals()의 차이)
        Integer newInteger = Integer.valueOf(10);
        System.out.println("== 비교: " + (integerObj == newInteger)); // false (객체 참조 비교)
        System.out.println("equals 비교: " + integerObj.equals(newInteger)); // true (값 비교)
    }
}

integerObj = 10
longObj = 100
doubleObj = 10.5
intValue = 10
longValue = 100
== 비교: false
equals 비교: true

 

Integer.valueOf() 최적화 (캐싱)

Integer.valueOf() 메서드는 -128 ~ 127 범위의 값을 캐싱하여 재사용한다.
이 범위 내의 값을 valueOf()로 생성하면 새로운 객체를 만들지 않고 기존 객체를 반환한다.

public class WrapperCacheTest {
    public static void main(String[] args) {
        Integer i1 = Integer.valueOf(127);
        Integer i2 = Integer.valueOf(127);
        Integer i3 = Integer.valueOf(128);
        Integer i4 = Integer.valueOf(128);

        System.out.println(i1 == i2); // true (캐싱된 객체 재사용)
        System.out.println(i3 == i4); // false (새로운 객체 생성)
    }
}

• `127` 이하의 값은 캐싱된 객체를 반환하므로 `i1 == i2` 는 `true` 가 된다.
• `128` 이상의 값은 새로운 객체를 생성하므로 `i3 == i4` 는 `false` 가 된다.

 

 

4. 래퍼 클래스 - 오토 박싱

자바 1.5부터 기본형과 래퍼 클래스 간의 변환을 자동으로 수행하는 오토 박싱(Auto-boxing)과 오토 언박싱(Auto-unboxing)을 지원한다.

 

오토 박싱과 오토 언박싱

1. 오토 박싱(Auto-boxing)

• 기본형을 래퍼 클래스로 변환하는 과정이 자동으로 수행된다.
• 예제: int → Integer
  

int value = 7;
Integer boxedValue = value; // 오토 박싱

 

2. 오토 언박싱(Auto-unboxing)

• 래퍼 클래스를 기본형으로 변환하는 과정이 자동으로 수행된다.
• 예제: Integer → int

Integer boxedValue = 7;
int unboxedValue = boxedValue; // 오토 언박싱

 

예제: 오토 박싱과 오토 언박싱 활용

public class AutoboxingMain {
    public static void main(String[] args) {
        // 오토 박싱 (Auto-boxing)
        Integer boxedValue = 10; // int → Integer 자동 변환
        Double boxedDouble = 5.5; // double → Double 자동 변환

        // 오토 언박싱 (Auto-unboxing)
        int unboxedValue = boxedValue; // Integer → int 자동 변환
        double unboxedDouble = boxedDouble; // Double → double 자동 변환

        System.out.println("boxedValue = " + boxedValue); // boxedValue = 10
        System.out.println("unboxedValue = " + unboxedValue); // unboxedValue = 10
        System.out.println("boxedDouble = " + boxedDouble); // boxedDouble = 5.5
        System.out.println("unboxedDouble = " + unboxedDouble); // unboxedDouble = 5.5
    }
}

• Integer와 Double 객체가 자동으로 박싱되었다.
• int와 double 값이 자동으로 언박싱되었다.

 

컴파일 단계에서의 코드 변환

자바 컴파일러는 오토 박싱과 오토 언박싱을 명시적인 변환 코드로 자동 추가한다.

Integer boxedValue = 10; // 오토 박싱
// 실제 컴파일 시 변환되는 코드:
Integer boxedValue = Integer.valueOf(10);

int unboxedValue = boxedValue; // 오토 언박싱
// 실제 컴파일 시 변환되는 코드:
int unboxedValue = boxedValue.intValue();

컴파일러가 valueOf()와 intValue()를 자동으로 추가해주므로 개발자는 변환을 직접 수행할 필요가 없다.

 

주의할 점: null 오토 언박싱 시 NullPointerException 발생

Integer nullInteger = null;
int value = nullInteger; // 자동 언박싱 시 NullPointerException 발생

• null인 Integer 객체를 int로 변환하려고 하면 NullPointerException이 발생한다.
• 따라서 오토 언박싱을 사용할 때는 null 여부를 반드시 확인해야 한다.

 

 

5. 래퍼 클래스 - 주요 메서드와 성능

래퍼 클래스 주요 메서드

자바의 래퍼 클래스는 다양한 유틸리티 메서드를 제공한다.

 

기본적인 변환 메서드

Integer i1 = Integer.valueOf(10); // 숫자로부터 객체 생성
Integer i2 = Integer.valueOf("10"); // 문자열로부터 객체 생성
int intValue = Integer.parseInt("10"); // 문자열을 기본형으로 변환

• `valueOf(String)`: 문자열을 래퍼 객체로 변환한다. 숫자, 문자열을 모두 지원한다.
• `parseInt(String)`: 문자열을 기본형으로 변환한다.

 

비교 메서드

int compareResult = i1.compareTo(20);
System.out.println(compareResult); // i1이 작으면 -1, 같으면 0, 크면 1

• `compareTo(int)`: 두 값을 비교하여 -1, 0, 1을 반환한다.

 

수학 연산 메서드

System.out.println(Integer.sum(10, 20)); // 30
System.out.println(Integer.min(10, 20)); // 10
System.out.println(Integer.max(10, 20)); // 20

• `sum(a, b)`: 두 수의 합을 반환한다.
• `min(a, b)`, `max(a, b)`: 최소값, 최대값을 반환한다.

 

 

래퍼 클래스와 성능

래퍼 클래스는 객체이므로 기본형보다 다양항 기능을 제공하지만, 성능이 떨어질 수 있다.

 

예제: 기본형 vs 래퍼 클래스 성능 비교

public class WrapperVsPrimitive {
    public static void main(String[] args) {
        int iterations = 1_000_000_000; // 10억번 연산

        // 기본형 long 사용
        long startTime = System.currentTimeMillis();
        long sumPrimitive = 0;
        for (int i = 0; i < iterations; i++) {
            sumPrimitive += i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("기본형 실행 시간: " + (endTime - startTime) + "ms");

        // 래퍼 클래스 Long 사용
        startTime = System.currentTimeMillis();
        Long sumWrapper = 0L;
        for (int i = 0; i < iterations; i++) {
            sumWrapper += i; // 오토 박싱 발생
        }
        endTime = System.currentTimeMillis();
        System.out.println("래퍼 클래스 실행 시간: " + (endTime - startTime) + "ms");
    }
}

 

결과 예시 (M2 맥북 기준)

기본형 실행 시간: 318ms
래퍼 클래스 실행 시간: 1454ms

• 기본형(long)이 래퍼 클래스(Long)보다 약 5배 빠르다.
• 기본형은 메모리에서 단순히 그 크기만큼의 공간을 차지한다. (`int`는 보통 4바이트)
• 래퍼 클래스의 인스턴스는 필드로 가지고 있는 기본형의 값 뿐만 아니라 객체 메타데이터를 포함하여 더 많은 메모리를 사용한다. (대략 8~16바이트 추가로 사용함)

 

기본형 vs 래퍼 클래스 선택 기준

• 기본형은 성능이 중요하고 수만~수십만 번 이상의 연산이 반복되는 경우에 사용한다.
• 래퍼 클래스는 유지보수성과 객체 지향적인 코드 작성을 위해 사용한다.
• 최신 하드웨어에서는 기본형과 래퍼 클래스의 차이가 크지 않으며, 대부분의 애플리케이션에서 가독성과 유지보수를 고려하는 것이 더 중요하다.
• 성능 최적화는 코드 변경 없이 가능하면 가장 좋지만, 불필요한 최적화는 코드의 복잡도를 증가시킬 수 있다.
• 특히 웹 애플리케이션에서는 연산 최적화보다 네트워크 호출을 줄이는 것이 더 효과적이므로, 성능 테스트를 통해 최적화가 필요한 부분을 명확히 파악한 후 적용하는 것이 바람직하다.

 

 

6. Class 클래스

자바의 Class 클래스는 클래스 메타정보를 다루는 기능을 제공한다.

 

Class 클래스의 주요 기능

1. 타입 정보 얻기

클래스의 이름, 슈퍼클래스, 인터페이스, 접근 제한자 등과 같은 정보를 조회할 수 있다.

 

예제: 클래스 정보 출력

// Class 조회 (3가지 방법)
Class clazz = String.class; // 1. 클래스에서 조회
// Class clazz = new String().getClass(); // 2. 인스턴스에서 조회
// Class clazz = Class.forName("java.lang.String");// 3. 문자열로 조회

// 모든 필드 출력
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
    System.out.println("field = " + field.getType() + " " + field.getName());
}

// 모든 메서드 출력
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
    System.out.println("method = " + method);
}

// 상위 클래스 정보 출력
System.out.println("Superclass: " + clazz.getSuperclass().getName());

// 인터페이스 정보 출력
Class[] interfaces = clazz.getInterfaces();
for (Class i : interfaces) {
    System.out.println("interface: " + i.getName());
}

 

실행 결과 (일부)

field = class [B value
method = byte[] java.lang.String.value()
Superclass: java.lang.Object
interface: java.io.Serializable

 

주요 기능

• `getDeclaredFields()`: 클래스의 모든 필드를 조회한다.
• `getDeclaredMethods()`: 클래스의 모든 메서드를 조회한다.
• `getSuperclass()`: 부모 클래스를 조회한다.
• `getInterfaces()`: 해당 클래스가 구현한 인터페이스 목록을 조회한다.

 

2. 리플렉션 (Reflection)

클래스에 정의된 메서드, 필드, 생성자 등을 조회하고, 이들을 통해 객체 인스턴스를 생성하거나 메서드 를 호출하는 등의 작업을 할 수 있다.

 

예제: 리플렉션을 이용한 객체 생성 및 메서드 호출

// 클래스 정보를 얻는다.
Class<?> clazz = Class.forName("lang.clazz.Hello");

// 인스턴스 생성
Object obj = clazz.getDeclaredConstructor().newInstance();

// 메서드 호출
Method method = clazz.getDeclaredMethod("hello");
String result = (String) method.invoke(obj);

System.out.println("Method Result: " + result);

package lang.clazz;

public class Hello {
    public String hello() {
        return "hello!";
    }
}

 

실행 결과

Method Result: hello!

• `getDeclaredConstructor().newInstance()`: 생성자를 조회하고 객체를 동적으로 생성한다.
• `getDeclaredMethod("hello")`: hello() 메서드를 조회한다.
• `method.invoke(obj)`: 동적으로 hello() 메서드를 호출한다.

리플렉션을 사용하면 클래스의 구조를 알지 못하더라도 실행 중에 객체를 생성하고, 메서드를 호출할 수 있다.
하지만 성능 오버헤드가 크기 때문에 남용하지 않는 것이 좋다.

 

3. 동적 로딩과 객체 생성

자바에서는 컴파일 시점이 아니라 실행 시점에 클래스 정보를 로드하여 객체를 생성하는 기능을 제공한다.

`Class.forName()` 메서드를 사용하여 클래스를 동적으로 로드하고, `newInstance()` 메서드를 통해 새로운 인스턴스를 생성할 수 있다.

 

예제: 동적 로딩을 이용한 객체 생성

// Class.forName()을 이용한 클래스 로딩
Class<?> helloClass = Class.forName("lang.clazz.Hello");

// 객체 생성
Hello hello = (Hello) helloClass.getDeclaredConstructor().newInstance();

// 메서드 실행
String result = hello.hello();
System.out.println("result = " + result); // result = hello!

• `Class.forName("클래스명")`: 클래스 이름을 문자열로 전달하면 해당 클래스를 로드할 수 있다.
• `getDeclaredConstructor().newInstance()`: 동적으로 객체를 생성한다.

이 방법은 외부 설정 파일에서 클래스명을 문자열로 읽어와 객체를 생성하는 경우에 유용하다.

 

4. 애노테이션 처리

클래스에 적용된 애노테이션(annotation)을 조회하고 처리하는 기능을 제공한다.
애노테이션을 이용하면 런타임에 특정 메서드나 필드에 대해 추가적인 정보를 제공하고 이를 활용할 수 있다.

 

예제: 애노테이션 조회

// 사용자 정의 애노테이션 생성
@interface MyAnnotation {
    String value();
}

public class AnnotationMain {
    @MyAnnotation(value = "테스트 애노테이션")
    public void testMethod() {}

    public static void main(String[] args) throws Exception {
        // 클래스 정보 조회
        Class<?> clazz = AnnotationMain.class;

        // 특정 메서드 조회
        Method method = clazz.getDeclaredMethod("testMethod");

        // 메서드에 적용된 애노테이션 출력
        Annotation[] annotations = method.getDeclaredAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("Annotation: " + annotation);
            // Annotation: @lang.clazz.MyAnnotation(value=테스트 애노테이션)
        }
    }
}

• `@interface MyAnnotation`: 사용자 정의 애노테이션을 생성한다.
• `method.getDeclaredAnnotations()`: 특정 메서드에 적용된 애노테이션을 조회한다.

애노테이션을 이용하면 프레임워크에서 런타임에 특정 동작을 수행하도록 설정할 수 있다.
예를 들어, Spring에서는 `@Service`, `@Controller`, `@Autowired` 등의 애노테이션을 사용하여 의존성 주입(DI), 서비스 등록 등의 기능을 수행한다.

 

 

7. System 클래스

System 클래스는 시스템과 관련된 다양한 기능을 제공한다.

 

시간 측정

System.out.println(System.currentTimeMillis()); // 현재 시간을 밀리초 단위로 반환
System.out.println(System.nanoTime()); // 나노초 단위 시간 반환

 

환경 변수 및 시스템 속성 조회

System.out.println(System.getenv("PATH")); // 환경 변수 조회
System.out.println(System.getProperty("java.version")); // 자바 버전 조회

• `System.getenv()` 메서드를 사용하여 OS에서 설정한 환경 변수의 값을 얻을 수 있다.
• `System.getProperties()` 를 사용해 현재 시스템 속성을 얻거나
  `System.getProperty(String key)` 로 특정 속성을 얻을 수 있다. 시스템 속성은 자바에서 사용하는 설정 값이다.

 

배열 고속 복사

char[] originalArray = {'h', 'e', 'l', 'l', 'o'};
char[] copiedArray = new char[5];
System.arraycopy(originalArray, 0, copiedArray, 0, originalArray.length);
System.out.println(Arrays.toString(copiedArray)); // [h, e, l, l, o]​

• `System.arraycopy()` 는 시스템 레벨에서 최적화된 메모리 복사 연산을 사용한다. 
  통째로 읽어서 복사하기 때문에 속도가 빠르다. (대략 2배 이상)

 

시스템 종료

System.exit(0); // 정상 종료
System.exit(1); // 오류 종료

• `System.exit(int status)` 메서드는 프로그램을 종료하고, OS에 프로그램 종료의 상태 코 드를 전달한다.
• 가급적이면 사용하지 않는 것을 권장한다. 의도대로 종료되지 않을 수 있기 때문이다.

 

 

8. Math & Random 클래스

Math 클래스

Math 클래스는 다양한 수학 연산을 제공한다.

 

자주 사용하는 메서드

// 기본 연산 메서드
System.out.println("max(10, 20): " + Math.max(10, 20)); // 최대값
System.out.println("min(10, 20): " + Math.min(10, 20)); // 최소값
System.out.println("abs(-10): " + Math.abs(-10)); // 절대값

// 반올림 및 정밀도 메서드
System.out.println("ceil(2.1): " + Math.ceil(2.1)); // 올림
System.out.println("floor(2.1): " + Math.floor(2.1)); // 내림
System.out.println("round(2.5): " + Math.round(2.5)); // 반올림

// 기타 유용한 메서드
System.out.println("sqrt(4): " + Math.sqrt(4)); // 제곱근
System.out.println("random(): " + Math.random()); // 0.0 ~ 1.0 사이의 double 값

 

실행 결과

max(10, 20): 20
min(10, 20): 10
abs(-10): 10
ceil(2.1): 3.0
floor(2.1): 2.0
round(2.5): 3
sqrt(4): 2.0
random(): 0.14752189985318276

 

참고: 아주 정밀한 숫자와 반올림 계산이 필요하다면 `BigDecimal` 을 사용한다. (ex: 정밀한 돈 계산)

 

Random 클래스

Random 클래스를 이용하면 다양한 형태의 난수를 생성할 수 있다.

참고로 `Math.random()` 도 내부에서는 Random 클래스를 사용한다.

Random 클래스는 java.util 패키지 소속이다.

 

Random random = new Random();
// Random random = new Random(1); // seed가 같으면 Random의 결과가 같다

int randomInt = random.nextInt();
System.out.println("randomInt = " + randomInt);

double rancomDouble = random.nextDouble(); // 0.0d ~ 1.0d
System.out.println("rancomDouble = " + rancomDouble);

boolean randomBoolean = random.nextBoolean();
System.out.println("randomBoolean = " + randomBoolean);

// 범위 조회
int randomRange1 = random.nextInt(10);// 0 ~ 9까지 출력
System.out.println("0 ~ 9: " + randomRange1);

int randomRange2 = random.nextInt(10) + 1;// 1 ~ 10까지 출력
System.out.println("1 ~ 10: " + randomRange2);

• `random.nextInt()` : 랜덤 int 값을 반환한다.
• `nextDouble()` : 0.0d ~ 1.0d 사이의 랜덤 double 값을 반환한다.
• `nextBoolean()` : 랜덤 boolean 값을 반환한다.
• `nextInt(int bound)` : 0 ~ bound 미만의 숫자를 랜덤으로 반환한다. 예를 들어서 3을 입력하면 0, 1, 2 를 반환한다.

1부터 특정 숫자의 int 범위를 구하는 경우 nextInt(int bound) 의 결과에 +1을 하면 된다.

 

랜덤 시드(Seed) 설정

Random fixedRandom = new Random(1); // seed가 같으면 Random의 결과가 같다

• `new Random(seed)`: 같은 시드를 사용하면 같은 난수가 생성된다.

 

new Random() vs new Random(seed)

• `new Random()`: 내부적으로 System.nanoTime()을 사용하여 매번 다른 난수를 생성한다. 반복 실행해도 결과가 항상 달라진다.
• `new Random(int seed)`: 같은 seed를 사용하면 항상 동일한 난수 패턴이 생성되어 여러번 반복 실행해도 실행 결과가 같다.  테스트, 시뮬레이션, 게임 맵 생성에 활용할 수 있다.