P-coding

자료형 변환시 주로 ParseInt가 권장된다.
하지만 valueOf 함수도 있는데 왜 저걸 권장할까?

ParseInt()

Java 라이브러리에서 ParseInt()는 다음과 같이 정의하고 있다.

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
}

기본 자료형( int )로 반환하며, 오버로딩(Overloading) 되어서 다시 재정의가 이루어진다.

다음은 오버로딩 ( Overloading ) 전체 코드이다. 문자열( s )를 진법( radix )을 통해 변환이 이루어진다.

public static int parseInt(String s, int radix)
            throws NumberFormatException
{
    /*
     * WARNING: This method may be invoked early during VM initialization
     * before IntegerCache is initialized. Care must be taken to not use
     * the valueOf method.
     */

    if (s == null) {
        throw new NumberFormatException("Cannot parse null string");
    }

    if (radix < Character.MIN_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " less than Character.MIN_RADIX");
    }

    if (radix > Character.MAX_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " greater than Character.MAX_RADIX");
    }

    boolean negative = false;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;

    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+') {
                throw NumberFormatException.forInputString(s, radix);
            }

            if (len == 1) { // Cannot have lone "+" or "-"
                throw NumberFormatException.forInputString(s, radix);
            }
            i++;
        }
        int multmin = limit / radix;
        int result = 0;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            int digit = Character.digit(s.charAt(i++), radix);
            if (digit < 0 || result < multmin) {
                throw NumberFormatException.forInputString(s, radix);
            }
            result *= radix;
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s, radix);
            }
            result -= digit;
        }
        return negative ? result : -result;
    } else {
        throw NumberFormatException.forInputString(s, radix);
    }
}

1. 초기 예외 검사

문자열(s)가 null이면 변환이 불가 함으로 NumberFormatException 예외 발생

if (s == null) {
    throw new NumberFormatException("Cannot parse null string");
}

radix(진법)이 2~36 진법 범위 내에서만 변환 가능함으로 Min, Max 값 범위 예외 처리

if (radix < Character.MIN_RADIX) {
    throw new NumberFormatException("radix " + radix +
                                    " less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
    throw new NumberFormatException("radix " + radix +
                                    " greater than Character.MAX_RADIX");
}

2. 부호 판별 및 기본 설정

부호 +(43), -(45)은 0(48)보다 아래이기 때문에 부호를 찾고 '+'은 무시 나머지 경우에만 처리한다.

'-'인 경우 음수로 설정하고, limit를 int 자료형의 변환이기 때문에 Integer.MIN_VALUE 로 설정한다.

        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+') {
                throw NumberFormatException.forInputString(s, radix);
            }

길이가 1이라면 앞 부호 하나만 있기 때문에 예외 처리

        if (len == 1) { // Cannot have lone "+" or "-"
            throw NumberFormatException.forInputString(s, radix);
        }

3. 숫자로 변환

먼저 자릿수를 가져오고, digit가 0보다 작거나 오버플로우가 나는지 체크한다.

사실 이 코드만 보고 이해하기는 어려울 수 있다. 성공과 실패의 두 가지 예시가 있다.

        int multmin = limit / radix;
        int result = 0;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            int digit = Character.digit(s.charAt(i++), radix);
            if (digit < 0 || result < multmin) {
                throw NumberFormatException.forInputString(s, radix);
            }
            result *= radix;
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s, radix);
            }
            result -= digit;
        }

ex) 성공한 연산 10진수 "2147483647"

 multmin = -2147483647 / 10 = -214748364

이 값을 통해 미리 오버플로우 발생을 예측한다.

마지막 결과에서 -2147483647을 부호판별 후 반환한다. -(-2147483647) = 2147483647

ex) 실패한 연산 10진수 "2147483648"

다음과 같은 결과로 ( result < limt + digit ) 조건이 참이 되어 예외가 발생하게 된다.

result = -2147483640
limit = -2147483647
digit = 8

limit + digit = -2147483647 + 8 = -2147483639

valueOf()

Java 라이브러리에서 valueOf()는 다음과 같이 정의하고 있다.

    public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }

객체형으로 반환하고 있고, 여기서도 오버로딩( Overloading ) 했던 parseInt()가 보인다.

또 하나 valueOf 메서드도 오버로딩( Overloading ) 되었는데 다음과 같다.

1. 미리 생성된 값 IntegerCache.low(-128) ~ IntegerCache.high(127) 사이면 새 객체를 생성하지 않고 반환한다.

2. 그 값이 아니라면 새로 객체를 생성하여 반환한다.

( 미리 생성되는 값 범위는 JVM option에 따라 조정 가능 )

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

(추가) parseInt() 사용 예

예제)

System.out.println(Integer.parseInt("123", 10));   // 123
System.out.println(Integer.parseInt("-123", 10));  // -123
System.out.println(Integer.parseInt("101", 2));    // 5 (2진수 변환)
System.out.println(Integer.parseInt("7F", 16));    // 127 (16진수 변환)
System.out.println(Integer.parseInt("Z", 36));     // 35 (36진수에서 'Z'는 35)
System.out.println(Integer.parseInt("007", 8));    // 7 (8진수)

예외발생)

System.out.println(Integer.parseInt("abc", 10));  // 예외 발생 (숫자가 없음)
System.out.println(Integer.parseInt("12345", 2)); // 예외 발생 (2진수 범위 초과)
System.out.println(Integer.parseInt("", 10));     // 예외 발생 (빈 문자열)
System.out.println(Integer.parseInt(null, 10));   // 예외 발생 (null)

결국 valueOf() 메서드도 parseInt()를 사용하며
Integer를 사용하지 않고, 정수만을 반환받기 원한다면 parseInt() 메서드를 사용해야 한다.
Integer객체를 통해 불필요하게 메모리를 사용하게 된다.

Integer와 Int 같은 정수형을 나타내는 자료형으로 볼 수 있다.
하지만 이는 객체와 기본형으로 다르게 같지만서도 다르다.
이번에는 그 차이를 알아보자.

1. primitive type ( 기본형 )

• 값 자체를 스택 메모리에 직접 저장하는 Primitive 즉, 원시적인 자료형이다. 
• 별도의 정의가 필요없이 사용할 수 있으며 고정된 크기를 차지한다.
• 메소드를 사용할 수 없으며 값을 직접 저장하기 때문에 null 을 저장할 수 없습니다.

2. Wrapper Class ( 객체형 )

• 값은 힙 메모리에 객체에 저장되고, 스택 메모리는 그 객체를 가리키는 주소값을 저장한다.
• 참조형 데이터이기 때문에 추가적인 메모리가 소모된다.
• 기본 상태는 null로 초기화 된다.

3. 메모리 구조 예시 ( 정수 )

다음과 같은 코드를 적용할 때 그림과 같이 메모리에 할당된다.

int num = 10;
Integer num = Integer.valueOf(num);

차이점 요약

Wrapper Class는 제네릭 형태로 자주 사용되며,
특히 List<Integer> 와 같은 컬렉션 프레임워크에서 흔히 활용된다.
간단한 코드에서는 당연하게 사용하지만,
방대한 코드 작성 시에는 메모리나 성능, 기능적 요소를 고려해야 한다.
이러한 상황에 닥쳤을 때 비로소 이유를 고민하기보다, 미리 원리를 이해하고 사용하면 더 효율적일 것이다.

문자열을 특정 구분자로 분리할 수 있는 StringTokenizer와 Splite을 사용하던 중
구체적인 차이점이 무엇인지 궁금하여 조사하게 되었다.
메모리에서 장점을 가진다고 하지만 정확히 어떤구조로 작용하는지 알아보자

StringTokenizer

StringTokenizer 클래스 내부를 살펴보면 다음과 같은 내용을 볼 수 있습니다.

    public StringTokenizer(String str, String delim, boolean returnDelims) {
        currentPosition = 0;
        newPosition = -1;
        delimsChanged = false;
        this.str = str;
        maxPosition = str.length();
        delimiters = delim;
        retDelims = returnDelims;
        setMaxDelimCodePoint();
    }

• 생성자 3가지

• 주요 메서드

1. StringTokenizer(String str)

public StringTokenizer(String str) {
        this(str, " \t\n\r\f", false);
}


StringTokenizer stringtokenizer = new StringTokenizer("Hello World\tJAVA");
	while (tokenizer.hasMoreTokens()) {
    		System.out.println(tokenizer.nextToken();
    	}

Hello
world
JAVA

• 기본 구분자 : 공백( ), 탭(\t), 줄바꿈(\n), 캐리지 리턴(\r), 폼 피드(\f)
• returnDelims는 기본적으로 false

2. StringTokenizer(String str, String delim)

  public StringTokenizer(String str, String delim) {
        this(str, delim, false);
 }

StringTokenizer stringTokenizer = new StringTokenizer("A,B|C", ",|");

while (stringTokenizer.hasMoreTokens()) {
	System.out.println(stringTokenizer.nextToken());
}

A
,
B
|
C

3. StringTokenizer(String str, String delim, boolean returnDelims)

public StringTokenizer(String str, String delim, boolean returnDelims) {
        currentPosition = 0;
        newPosition = -1;
        delimsChanged = false;
        this.str = str;
        maxPosition = str.length();
        delimiters = delim;
        retDelims = returnDelims;
        setMaxDelimCodePoint();
}

StringTokenizer stringTokenizer = new StringTokenizer("A,B|C", ",|", true);

while (stringTokenizer.hasMoreTokens()) {
    System.out.println(stringTokenizer.nextToken());
}

A
,
B
| C

다음과 같은 생성자를 가지고 있는데 코드를 살펴보면 단 하나의 구분자로만 사용되는 것으로 보인다.

즉, 구분자 문자가 개별로 작용하여 하지만 String 클래스의 split은 ,| 를 하나의 구분자로 사용할 수 있다.

Split

split 메드는 문자열을 특정 정규식(regex)을 기준으로 나눈다.

다음은 String 클래스에 있는 split 메서드이다.

    public String[] split(String regex) {
        return split(regex, 0);
    }
    
    
    public String[] split(String regex, int limit) {
        char ch = 0;
        if (((regex.length() == 1 &&
             ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
             (regex.length() == 2 &&
              regex.charAt(0) == '\\' &&
              (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
              ((ch-'a')|('z'-ch)) < 0 &&
              ((ch-'A')|('Z'-ch)) < 0)) &&
            (ch < Character.MIN_HIGH_SURROGATE ||
             ch > Character.MAX_LOW_SURROGATE))
        {
            int off = 0;
            int next = 0;
            boolean limited = limit > 0;
            ArrayList<String> list = new ArrayList<>();
            while ((next = indexOf(ch, off)) != -1) {
                if (!limited || list.size() < limit - 1) {
                    list.add(substring(off, next));
                    off = next + 1;
                } else {    // last one
                    //assert (list.size() == limit - 1);
                    int last = length();
                    list.add(substring(off, last));
                    off = last;
                    break;
                }
            }
            // If no match was found, return this
            if (off == 0)
                return new String[]{this};

            // Add remaining segment
            if (!limited || list.size() < limit)
                list.add(substring(off, length()));

            // Construct result
            int resultSize = list.size();
            if (limit == 0) {
                while (resultSize > 0 && list.get(resultSize - 1).isEmpty()) {
                    resultSize--;
                }
            }
            String[] result = new String[resultSize];
            return list.subList(0, resultSize).toArray(result);
        }
        return Pattern.compile(regex).split(this, limit);
    }

위를 보면 limit을 통해 배열의 길이를 조절할 수 있다.

로직을 보기 전까지는 사실 어떻게 작동하는 지 헷갈릴 수 있다.

A, B, C와 2를 대입하여 사용한다면 A와 B인지 A와 B,C 인지...

그것을 보여주는 코드예시이다.

public class SplitExample {
    public static void main(String[] args) {
        String str = "apple,banana,cherry,orange,grape";

        String[] result = str.split(",", 3);

        for (String token : result) {
            System.out.println(token);
        }
    }
}

apple
banana
cherry,orange,grape

split은 구분자를 찾아 subString으로 분리반복하고 결과 배열을 생성하는 것을 볼 수 있다.

그리고 빈 문자열, 구분자 사이에 문자가 없는 경우

,,

StringTokenizer는 이를 무시하지만 split은 빈 문자열로 간주한다.

StringTokenizer와 split의 차이는 다음과 같다.

둘 중 누가 성능이 좋은가?

정규식이나 복잡한 패턴이 아닌 두 메서드 모두 가능한 구분자로 진행하였을 때, 어느 때 어떤 메서드가 성능이 좋은지 4가지 기준으로 분류했다. 4가지 기준은 다음과 같다

• 유니코드를 사용한 경우
• 긴 문자열과 한 가지 구분자를 사용한 경우
• 짧은 문자열과 한 가지 구분자를 사용한 경우
• 짧은 문자열과 여러 구분자를 동시에 사용한 경우

StringTokenizer 한 가지 구분자로 이루어진 문자열을 사용한 경우는 문자열이 길든 짧든 항상 빨랐다.

split()은 여러 구분자와 유니코드를 사용한 경우에 빨랐다. 

StringTokenizer

StringTokenizer 클래스의 내부를 살펴보면 구분자에 따라 성능이 좌우된다.

StringTokenizer 클래스 scanToken 메서드

    private int scanToken(int startPos) {
        int position = startPos;
        while (position < maxPosition) {
            if (!hasSurrogates) {
                char c = str.charAt(position);
                if ((c <= maxDelimCodePoint) && (delimiters.indexOf(c) >= 0))
                    break;
                position++;
            } else {
                int c = str.codePointAt(position);
                if ((c <= maxDelimCodePoint) && isDelimiter(c))
                    break;
                position += Character.charCount(c);
            }
        }
        if (retDelims && (startPos == position)) {
            if (!hasSurrogates) {
                char c = str.charAt(position);
                if ((c <= maxDelimCodePoint) && (delimiters.indexOf(c) >= 0))
                    position++;
            } else {
                int c = str.codePointAt(position);
                if ((c <= maxDelimCodePoint) && isDelimiter(c))
                    position += Character.charCount(c);
            }
        }
        return position;
    }

( hasSurrogates는 유니코드인지 확인하는 것이고 indexOf와 isDelimiter 메서드는 같은 로직이다. )

여기서 성능에 영향을 끼치는 것은 indexOf() 메서드 이다. 이는 순차탐색으로 최악의 경우 O(|delimiter|)의 시간이 걸린다.

모든 문자에 이 코드를 작동된다고 생각한다면 성능은 구분자의 개 수에 따라 달라진다. 다음 예시를 보자

아스키 코드 값

@ : 64

, : 44

< : 60

{ : 123

@ 찾는 경우

< 찾는 경우

} ( 없는 구분자 ) 를 찾는 경우

}  는 아스키 코드 값이 125이기 때문에 maxDelimCodePoint ( 123 ) 보다 크다.

때문에 탐색되지 않는다.

구분자가 아닌 문자 A인 경우

A( 65 ) < maxDelimCodePoint (125)

때문에 모두 탐색해본다.

이처럼 단순 문자일 경우도 모두 탐색한다. 그래서 구분자가 많으면 많을수록 괴랄하게 탐색시간이 늘어난다.

유니코드라면 두 개의 char 를 쓰기 때문에 더욱 더 심각해진다.

split()

• split 메서드는 정규식을 사용하여 구분자를 기준으로 문자열을 나눈다.
• Pattern 클래스(정규 표현식 엔진)를 활용해 문장열을 순회, 구분자를 매칭한다.
• 그 구분자 자리를 기억하고 문자열을 자른다.

다음과 같이 표현할 수 있다.

String input = "apple,banana,grape";
String[] result = input.split(",");

매칭 과정

1. 구분자 ,를 문자열에서 찾기 시작.
   • 첫 번째 ,의 위치: 5.
   • 두 번째 ,의 위치: 12.
2. 매칭된 위치: [5, 12].

자르는 위치 계산

구분자의 위치를 기반으로 문자열을 나눕니다:

• 첫 번째 구분자의 앞부분 → 0~5 ("apple").
• 첫 번째 구분자와 두 번째 구분자의 사이 → 6~12 ("banana").
• 마지막 구분자 이후 → 13~끝 ("grape").

때문에  StringTokenizer가 많은 구분자나 유니코드를 문자마다 확인하는 경우에 정규 표현식 엔진으로 보다 빠르게 비교할 수 있고 문자열을 자르기 때문에 split() 성능이 좋지만, 정규 표현식 엔진의 기본 처리 시간이 StringTokenizer가 한 개의 구분자를 비교하는 것보다는 느린 경우가 많다. 또한 긴 문자열일 때 종종 같은 구분자라도 split() 빠른 경우가 있는데.. 같은 문자열을 길게 복사한 것이라서 모든 문자가 구분자의 코드 포인트보다 낮아 코드를 끝까지 읽어서 느린 경우가 아닌 찾아보니 split()은 JVM 메모리 관리 측면에서 같은 문자를 나누는 기준은 캐싱되어 성능이 최적화될 수 있다고 한다.

그렇다면 무엇을 사용해야 할까?
자바에서는 다음과 같이 설명하고 있다.

사실  StringTokenizer는 레거시 클래스이다?

StringTokenizer is a legacy class that is retained for compatibility reasons although its use is discouraged in new code. It is recommended that anyone seeking this functionality use the split method of String or the java.util.regex package instead.

호환성 이유로 유지되는 레거시 클래스이며 새로운 코드에서는 사용이 권장되지 않음. 대신 Split이나 java.util.regex 패키지를 사용하는 것이 좋다.

출처 : JAVA StringTokenizer

StringTokenizer는 사용하면 안될까?

결론적으로는 그렇다고 생각한다. JDK가 업데이트 됨에 따라 레거시 클래스는 삭제될 수도 있다.

JDK가 업데이트 되었다고 해서 사용하던 JDK를 바로 당장 전부 업데이트하지 않겠지만,

미래 지향적으로 본다면 그렇다고 생각한다.

새로운 개발 환경에서 시작하는 일이 잦다 보니
개발 필수 도구들을 설치하는 것에 대한 가이드라인을 작성해보려고 한다.
간단한 설치와 환경 변수 설정까지 단계별로 다루겠다.

1. JAVA 다운로드 및 설치 준비

1-1. 설치 파일 다운로드

• 오라클 홈페이지에서 JDK(JAVA Development Kit) 버전과 운영체제에 맞는 파일을 다운로드 해줍니다.
• 윈도우 11부터는 32비트 지원을 제공하지 않기 때문에 윈도우 최신 자바 버전도 64비트만 존재합니다.

어떤 것을 다운로드 해도 상관없으나

Windows 환경 기준으로 MSI 설치파일을 사용하면 환경변수까지 자동으로 설정해주기 때문에 MSI Installer를 추천한다.

+

기본적으로 Installer, MSI Installer는 C:\Program\Files\Java 파일경로에 설치되고

Compressed Archive는 직접 파일 경로를 설정하고 설치한다.

1-2. 설치 완료 후 확인

• 아래 작업표시줄 검색에 명령 터미널, 프롬포트나 cmd를 검색해 실행한다.
• 다음 명령어를 통해 자바가 설치되었는지 확인한다.

java -version

다음과 같이 버전 정보가 표시되면 설치가 성공적으로 완료되었다. 

하지만 version이 확인 되지 않는다면 환경 변수가 설정되지 않았기 때문이다. 

다음 환경 변수 설정을 보자

2. 환경 변수 설정 (Windows 기준)

2 - 1. 작업 표시줄 검색창에 "환경 변수 편집"을 입력하고 선택

2 - 2. "환경 변수" 클릭

2 - 3. 새로 만들기 클릭하고 다음과 같이 입력 ( 파일 위치에 맞게 되어있는지 검토하셔야 합니다. )

C:\Program Files\Java\jdk-23

2 - 4. "Path" 찾아서 더블 클릭

새로만들기를 통해 다음과 같은 항목을 추가해 준다.

%JAVA_HOME%\bin

3. VS Code 설치

3 - 1. Visual Code 설치

다음 사이트를 통해 VS Code를 다운 받아준다.

3 - 2. 유용한 Extensions (확장 프로그램) 추가

다음과 같은 확장 프로그램을 검색을 통해 추가해 주면 좋다.

필수 확장 프로그램

1. Language Support for Java(TM) by Red Hat

• 기본 Java 언어 지원 (코드 완성, 오류 탐지, 문법 강조 등).

2. Debugger for Java

• Java 애플리케이션 디버깅 지원

3. Java Extension Pack

• Red Hat Java 확장과 관련된 모든 패키지 한번에 설치 가능

Java 개발에 유용한 확장 프로그램은 다양하지만,
중복되거나 너무 많은 확장 프로그램을 설치하면 혼란을 야기할 수 있다.
따라서 본인의 개발 환경과 필요에 따라 적절한 확장 프로그램을 선택하고 사용하는 것이 중요하다

필수적인 도구만 설치하여 효율적이고 깔끔한 개발 환경을 유지하는 것을 추천한다.

JAVA 에서는 System.out과 System.err는 출력 스트림(Output Stream)으로 각각 특정 목적과 동작 방식에 맞게 사용됩니다. 그 두가지에는 무슨 차이점이 있는지 알아보겠습니다.

---

System.out 특징

• 일반 출력용 스트림으로, 프로그램의 정상적인 실행 결과를 출력
• 출력 내용을 버퍼(buffer)에 임시 저장 후 특정 조건에 한 번에 출력
• 이로 인해 출력 순서가 보장되지 않을 수 있습니다.

System.err 특징

• 에러 출력용 스트림으로 에러나 크리티컬한 상황에 대한 기록
• 중요한 메시지를 즉각적으로 보여주기 위해 자동으로 출력
• 따라서 실행 중 바로 확인 가능하며, 디버깅 시 유용하게 사용될 수 있습니다.

예시

코드

System.out.println("3 x 3 = ");
System.out.err("9");

출력 예시

9
3 x 3 =