개요

---

알고리즘을 풀다보면, 필연적으로 입력값 처리를 하게된다. 다양한 케이스에 대응하기 위해, 사용자의 값을 직접 입력받아 이를 처리하게 된다. 이 때, 우리는 십중팔구 이와 같은 상황이 발생한다. 데이터셋을 보내기 위해 데이터의 모음을 구분자(공백 혹은 쉼표)를 통해 하나의 문자열로 합쳐 전달한다.

이를테면, 위와 같이 $[ "A", "B", "C", "D" ]$와 같은 배열을 전달하기 위해, 각 요소를 공백으로 구분하여 $"A B C D"$와 같이 전달하게 된다. 보통 내 경우 split 메소드를 활용하는데, 알고리즘 풀이를 찾아보다보니 StringTokenizer이라는 class를 쓰는 코드들이 더러있었다. 처음보는 class인데다, 접근성이 훨씬 뛰어난 split를 굳이 대체해서 쓰는 이유가 있을거라 판단. 직접 퍼포먼스를 비교해보기로 했다. 알고리즘은 수행속도 역시 중요한 지표로 작용하기 때문에, 조금이라도 시간을 줄일 필요가 있다. 안타깝게도 나는 코드 최적화 실력이 최악이라, 이런식으로 줄일 수 있는 자잘한 부분은 줄여야한다. 핵심 코드를 최적화할 생각은 안 하고 이런데서 시간을 단축하는게 꼭 다이어트한답시고 피자 먹으면서 제로콜라 마시는 느낌이긴 하나, StringTokenizer이 더 성능이 뛰어나다면 앞으로 푸는 알고리즘에 적용할 가치가 있을 것이다.

테스트 환경

---

split 메소드

---

split 메소드는 특정 구분자로 문자열을 분리하는 전통적인 메소드다. 굳이 JAVA가 아니더라도 C(++, #), JavaScript, Python 등 여러 언어에 존재하는 키워드라 어떤 언어든 문자열을 구분할 때 제일 먼저 시도하는 방법이다.

JAVA의 split은 문자열 데이터 형식인 String class에 포함된 메소드다. 문자열 데이터라면 split를 호출하여 문자열을 구분할 수 있다. 반환값은 String[] 객체.

사용법은 아래와 같다.

JAVA
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Arrays;

/**
 * 메인 클래스
 *
 * @author RWB
 * @since 2021.06.13 Sun 22:50:57
 */
public class Main
{
	/**
	 * 메인 함수
	 *
	 * @param args: [String[]] 매개변수
	 */
	public static void main(String[] args)
	{
		String text = "A B C D";
		
		String[] splited = text.split(" ");
		
		System.out.println(Arrays.toString(splited));
	}
}

출력은 아래와 같다.

TC
1
[A, B, C, D]

문자열 A B C D가 공백을 기준으로 [A, B, C, D]로 분리된걸 확인할 수 있다. 그 밖에 한 가지 특이한 점이 있는데, JAVA의 split 메소드는 구분자에 정규식을 적용할 수 있다. 이를 잘만 이용하면 복합적인 구분자를 사용할 수도 있다.

StringTokenizer

---

이 포스팅을 쓰게 만든 직접적인 원인. StringTokenizer 역시 문자열을 구분하는데 특화된 class의 일종이다. String[]을 반환하는 split과 달리 그 자체로 하나의 개별적인 class라는 차이가 있다.

StringTokenizer tokenizer = new StringTokenizer("문자열");과 같은 형태로 초기화해서 사용한다. StringTokenizer 인스턴스를 사용하는데 알아두면 좋을법한 메소드는 아래와 같다.

StringTokenizer tokenizer = new StringTokenizer("문자열", "구분자");와 같이 생성자의 인수에 구분자를 추가하여 원하는 구분자로 구분하게 할 수도 있다. 별도로 지정하지 않는다면 구분자는 \t\n\r\t로, 줄바꿈, 공백, 탭을 구분한다. 여기서 주의할 점이 하나 있는데, 기본 구분자 \t\n\r\t는 줄바꿈, 공백, 탭을 전부 포함한다. 즉, A B C D\nA B C D와 같이 공백과 줄바꿈이 혼용되어 있을 경우, 공백과 줄바꿈을 전부 구분하여 [A, B, C, D, A, B, C, D]와 같이 출력된다. 생성자에 구분자를 강제로 지정해줄 경우, 이를 막을 수 있다. 직접 지정할 경우 공백이나 줄바꿈이 아니더라도 여러 문자열을 사용할 수 있다.

JAVA
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
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * 메인 클래스
 *
 * @author RWB
 * @since 2021.06.13 Sun 23:48:14
 */
public class Test
{
	/**
	 * 메인 함수
	 *
	 * @param args: [String[]] 매개변수
	 */
	public static void main(String[] args)
	{
		String text = "A B C D";
		
		StringTokenizer tokenizer = new StringTokenizer(text);
		
		String[] splited = new String[tokenizer.countTokens()];
		
		for (int i = 0; i < splited.length; i++)
		{
			splited[i] = tokenizer.nextToken();
		}
		
		System.out.println(Arrays.toString(splited));
	}
}

출력은 동일하다.

TC
1
[A, B, C, D]

속도 비교

---

그렇다면 split과 StringTokenizer의 성능은 어떨까? 이를 비교하기 위해 간단한 테스트 프로그램을 만들었다.

1. 반복횟수 t가 할당된다.
2. 케이스마다 5 ~ 20자의 랜덤한 문자열을 생성한다. 각 문자 사이엔 공백이 포함된다.
3. 공백을 구분자로 문자열을 구분한다
   1. split 사용
   2. StringTokenizer 사용
4. 총 소요 시간 및 평균 소요 시간을 계산한다
5. 결과를 표시한다

소스는 아래와 같다.

JAVA
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

/**
 * 메인 클래스
 *
 * @author RWB
 * @since 2021.06.14 Mon 00:06:32
 */
public class Main
{
	/**
	 * 메인 함수
	 *
	 * @param args: [String[]] 매개변수
	 */
	public static void main(String[] args)
	{
		int t = 10000;
		
		long[] timer = { 0, 0 };
		
		int[] sum = { 0, 0 };
		
		for (int i = 0; i < t; i++)
		{
			int random = (int) ((Math.random() * (20 - 5)) + 5);
			
			String text = getTestString(random);
			
			// split 로직 ----------------------------------------
			long timeStart = System.nanoTime();
			
			String[] a1 = useSplit(text);
			
			long timeEnd = System.nanoTime() - timeStart;
			
			sum[0] += a1.length;
			
			timer[0] += timeEnd;
			
			System.out.println(Arrays.toString(a1) + ": " + addComma(timeEnd) + "ns");
			// split 로직 ----------------------------------------
			
			// StringTokenizer 로직 ----------------------------------------
			timeStart = System.nanoTime();
			
			String[] a2 = useStringTokenizer(text);
			
			timeEnd = System.nanoTime() - timeStart;
			
			sum[1] += a2.length;
			
			timer[1] += timeEnd;
			
			System.out.println(Arrays.toString(a2) + ": " + addComma(timeEnd) + "ns");
			// StringTokenizer 로직 ----------------------------------------
		}
		
		System.out.println(addComma(t) + "개 데이터 그룹 수행");
		
		System.out.println();
		
		System.out.println("split 결과");
		System.out.println(" * 총 소요: " + addComma(timer[0]) + "ns");
		System.out.println(" * 평균 소요: " + addComma((timer[0] / t)) + "ns");
		System.out.println(" * 분해한 요소: " + addComma(sum[0]) + "개");
		
		System.out.println();
		
		System.out.println("StringTokenizer 결과");
		System.out.println(" * 총 소요: " + addComma(timer[1]) + "ns");
		System.out.println(" * 평균 소요: " + addComma((timer[1] / t)) + "ns");
		System.out.println(" * 분해한 요소: " + addComma(sum[1]) + "개");
		
		System.out.println();
		
		System.out.println("split " + (timer[0] == timer[1] ? "==" : (timer[0] > timer[1]) ? "<" : ">") + " StringTokenizer");
	}
	
	/**
	 * 구분된 문자열 반환 함수 (split)
	 *
	 * @param text: [String] 대상 문자열
	 *
	 * @return [String[]] 구분된 문자열
	 */
	private static String[] useSplit(String text)
	{
		return text.split(" ");
	}
	
	/**
	 * 구분된 문자열 반환 함수 (StringTokenizer)
	 *
	 * @param text: [String] 대상 문자열
	 *
	 * @return [String[]] 구분된 문자열
	 */
	private static String[] useStringTokenizer(String text)
	{
		StringTokenizer tokenizer = new StringTokenizer(text, " ");
		
		int count = tokenizer.countTokens();
		
		String[] result = new String[count];
		
		for (int i = 0; i < count; i++)
		{
			result[i] = tokenizer.nextToken();
		}
		
		return result;
	}
	
	/**
	 * 무작위 문자열 반환 함수
	 *
	 * @param n: [int] 문자 갯수
	 *
	 * @return [String] 무작위 문자
	 */
	private static String getTestString(int n)
	{
		Random random = new Random();
		
		StringBuilder builder = new StringBuilder();
		
		for (int i = 0; i < n; i++)
		{
			builder.append((char) ((random.nextInt(26)) + 97)).append(" ");
		}
		
		return builder.toString().trim();
	}
	
	/**
	 * 1000 단위 구분 숫자 반환 함수
	 *
	 * @param num: [long] 대상 숫자
	 *
	 * @return [String] 1000 단위 구분 숫자
	 */
	private static String addComma(long num)
	{
		DecimalFormat format = new DecimalFormat(",###");
		
		return format.format(num);
	}
}

횟수별로 10번씩 돌린 결과를 아래의 표로 정리했다.

• $t = 1$

한 번만 반복할 경우, 8:2로 StringTokenizer이 압승한다.

• $t = 100$

100번을 반복할 때 역시 10:0으로 StringTokenizer이 압승한다.

• $t = 1,000$

$2^1$, $2^3$처럼 끊어가다가 뜬금없이 1000을 넣은 이유는, 이상하게 $t = 1,000$일 땐 split이 압승한다.

• $t = 10,000$

다시 8:2로 StringTokenizer이 압승한다.

• $t = 1,000,000$

8:2로 StringTokenizer이 압승한다.

$t = 1,000$이라는 특수한 상황을 제외하고는 보편적으로 StringTokenizer가 성능이 더 우수하다. 저런 현상이 왜 발생하는지 이해는 잘 안 된다. 물론 통계라는게 숫자가 클 수록 의미가 커지므로 10번이라는 작은 횟수만으로 단정짓긴 어렵다.

회사 컴퓨터(AMD Ryzen 2700X)에서는 모든 케이스에서 StringTokenizer의 속도가 빨랐다. CPU에 따라 연산 결과나 방식에 조금씩 차이가 있을 순 있겠다.

🔗 JAVA API에 의하면, StringTokenizer은 하위 호환성을 보장하기 위한 레거시 클래스라고 한다. JAVA API는 가급적 StringTokenizer보다 split 내지는 regex 패키지를 활용하도록 권고하고 있다.

결론

---

표의 수치 상 StringTokenizer가 split에 비해 최대 약 20% 정도 더 빠르다. 하지만 JAVA API에서 가급적 다른 대체제를 사용하도록 권고하고 있고, 백만번의 연산에도 $ms$ 단위에서 움직인다. 상대적으론 차이가 있어도 객관적인 지표로 봤을땐 별다른 차이가 없는 셈. 문자열 분리하자고 새로운 class를 다룰 바에 그냥 문자열 자체를 다루는 split을 사용하는 게 더 효율적이라 생각한다.