π…λ²ˆμ§Έ μ•ŒνŒŒμΉ΄μ˜ 개발 λ‚™μ„œμž₯

screen

[JAVA] split vs StringTokenizer

posts

JAVA

count

κ°œμš” πŸ”—

μ•Œκ³ λ¦¬μ¦˜μ„ 풀닀보면, ν•„μ—°μ μœΌλ‘œ μž…λ ₯κ°’ 처리λ₯Ό ν•˜κ²Œλœλ‹€. λ‹€μ–‘ν•œ μΌ€μ΄μŠ€μ— λŒ€μ‘ν•˜κΈ° μœ„ν•΄, μ‚¬μš©μžμ˜ 값을 직접 μž…λ ₯λ°›μ•„ 이λ₯Ό μ²˜λ¦¬ν•˜κ²Œ λœλ‹€. 이 λ•Œ, μš°λ¦¬λŠ” μ‹­μ€‘νŒ”κ΅¬ 이와 같은 상황이 λ°œμƒν•œλ‹€. 데이터셋을 보내기 μœ„ν•΄ λ°μ΄ν„°μ˜ λͺ¨μŒμ„ κ΅¬λΆ„μž(곡백 ν˜Ήμ€ μ‰Όν‘œ)λ₯Ό 톡해 ν•˜λ‚˜μ˜ λ¬Έμžμ—΄λ‘œ 합쳐 μ „λ‹¬ν•œλ‹€.

이λ₯Όν…Œλ©΄, μœ„μ™€ 같이 와 같은 배열을 μ „λ‹¬ν•˜κΈ° μœ„ν•΄, 각 μš”μ†Œλ₯Ό 곡백으둜 κ΅¬λΆ„ν•˜μ—¬ 와 같이 μ „λ‹¬ν•˜κ²Œ λœλ‹€. 보톡 λ‚΄ 경우 split λ©”μ†Œλ“œλ₯Ό ν™œμš©ν•˜λŠ”λ°, μ•Œκ³ λ¦¬μ¦˜ 풀이λ₯Ό μ°Ύμ•„λ³΄λ‹€λ³΄λ‹ˆ StringTokenizerμ΄λΌλŠ” classλ₯Ό μ“°λŠ” μ½”λ“œλ“€μ΄ λ”λŸ¬μžˆμ—ˆλ‹€. μ²˜μŒλ³΄λŠ” class인데닀, 접근성이 훨씬 λ›°μ–΄λ‚œ splitλ₯Ό ꡳ이 λŒ€μ²΄ν•΄μ„œ μ“°λŠ” μ΄μœ κ°€ μžˆμ„κ±°λΌ νŒλ‹¨. 직접 퍼포먼슀λ₯Ό λΉ„κ΅ν•΄λ³΄κΈ°λ‘œ ν–ˆλ‹€. μ•Œκ³ λ¦¬μ¦˜μ€ μˆ˜ν–‰μ†λ„ μ—­μ‹œ μ€‘μš”ν•œ μ§€ν‘œλ‘œ μž‘μš©ν•˜κΈ° λ•Œλ¬Έμ—, μ‘°κΈˆμ΄λΌλ„ μ‹œκ°„μ„ 쀄일 ν•„μš”κ°€ μžˆλ‹€. μ•ˆνƒ€κΉκ²Œλ„ λ‚˜λŠ” μ½”λ“œ μ΅œμ ν™” μ‹€λ ₯이 μ΅œμ•…μ΄λΌ, μ΄λŸ°μ‹μœΌλ‘œ 쀄일 수 μžˆλŠ” μžμž˜ν•œ 뢀뢄은 μ€„μ—¬μ•Όν•œλ‹€. 핡심 μ½”λ“œλ₯Ό μ΅œμ ν™”ν•  생각은 μ•ˆ ν•˜κ³  μ΄λŸ°λ°μ„œ μ‹œκ°„μ„ λ‹¨μΆ•ν•˜λŠ”κ²Œ κΌ­ λ‹€μ΄μ–΄νŠΈν•œλ‹΅μ‹œκ³  ν”Όμž λ¨ΉμœΌλ©΄μ„œ 제둜콜라 λ§ˆμ‹œλŠ” λŠλ‚Œμ΄κΈ΄ ν•˜λ‚˜, StringTokenizer이 더 μ„±λŠ₯이 λ›°μ–΄λ‚˜λ‹€λ©΄ μ•žμœΌλ‘œ ν‘ΈλŠ” μ•Œκ³ λ¦¬μ¦˜μ— μ μš©ν•  κ°€μΉ˜κ°€ μžˆμ„ 것이닀.

ν…ŒμŠ€νŠΈ ν™˜κ²½ πŸ”—

ꡬ뢄 λ‚΄μš©
μ–Έμ–΄ JAVA
OS Windows 10 64bit
CPU Intel i7-10700K
RAM 32GB

split λ©”μ†Œλ“œ πŸ”—

split λ©”μ†Œλ“œλŠ” νŠΉμ • κ΅¬λΆ„μžλ‘œ λ¬Έμžμ—΄μ„ λΆ„λ¦¬ν•˜λŠ” 전톡적인 λ©”μ†Œλ“œλ‹€. ꡳ이 JAVAκ°€ μ•„λ‹ˆλ”λΌλ„ C(++, #), JavaScript, Python λ“± μ—¬λŸ¬ 언어에 μ‘΄μž¬ν•˜λŠ” ν‚€μ›Œλ“œλΌ μ–΄λ–€ μ–Έμ–΄λ“  λ¬Έμžμ—΄μ„ ꡬ뢄할 λ•Œ 제일 λ¨Όμ € μ‹œλ„ν•˜λŠ” 방법이닀.

JAVA의 split은 λ¬Έμžμ—΄ 데이터 ν˜•μ‹μΈ String class에 ν¬ν•¨λœ λ©”μ†Œλ“œλ‹€. λ¬Έμžμ—΄ 데이터라면 splitλ₯Ό ν˜ΈμΆœν•˜μ—¬ λ¬Έμžμ—΄μ„ ꡬ뢄할 수 μžˆλ‹€. λ°˜ν™˜κ°’μ€ String[] 객체.

μ‚¬μš©λ²•μ€ μ•„λž˜μ™€ κ°™λ‹€.

JAVA

0import java.util.Arrays;
1
2/**
3 * 메인 클래슀
4 *
5 * @author RWB
6 * @since 2021.06.13 Sun 22:50:57
7 */
8public class Main
9{
10 /**
11 * 메인 ν•¨μˆ˜
12 *
13 * @param args: [String[]] λ§€κ°œλ³€μˆ˜
14 */
15 public static void main(String[] args)
16 {
17 String text = "A B C D";
18
19 String[] splited = text.split(" ");
20
21 System.out.println(Arrays.toString(splited));
22 }
23}

좜λ ₯은 μ•„λž˜μ™€ κ°™λ‹€.

TC

0[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 μΈμŠ€ν„΄μŠ€λ₯Ό μ‚¬μš©ν•˜λŠ”λ° μ•Œμ•„λ‘λ©΄ μ’‹μ„λ²•ν•œ λ©”μ†Œλ“œλŠ” μ•„λž˜μ™€ κ°™λ‹€.

λ©”μ†Œλ“œ λ°˜ν™˜κ°’ λ‚΄μš©
countToken int ν† ν°μ˜ 갯수
nextToken String λ‹€μŒ 토큰
hasMoreTokens boolean λ‹€μŒ ν† ν°μ˜ 쑴재 유무

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

0import java.util.Arrays;
1import java.util.StringTokenizer;
2
3/**
4 * 메인 클래슀
5 *
6 * @author RWB
7 * @since 2021.06.13 Sun 23:48:14
8 */
9public class Test
10{
11 /**
12 * 메인 ν•¨μˆ˜
13 *
14 * @param args: [String[]] λ§€κ°œλ³€μˆ˜
15 */
16 public static void main(String[] args)
17 {
18 String text = "A B C D";
19
20 StringTokenizer tokenizer = new StringTokenizer(text);
21
22 String[] splited = new String[tokenizer.countTokens()];
23
24 for (int i = 0; i < splited.length; i++)
25 {
26 splited[i] = tokenizer.nextToken();
27 }
28
29 System.out.println(Arrays.toString(splited));
30 }
31}

좜λ ₯은 λ™μΌν•˜λ‹€.

TC

0[A, B, C, D]

속도 비ꡐ πŸ”—

κ·Έλ ‡λ‹€λ©΄ splitκ³Ό StringTokenizer의 μ„±λŠ₯은 μ–΄λ–¨κΉŒ? 이λ₯Ό λΉ„κ΅ν•˜κΈ° μœ„ν•΄ κ°„λ‹¨ν•œ ν…ŒμŠ€νŠΈ ν”„λ‘œκ·Έλž¨μ„ λ§Œλ“€μ—ˆλ‹€.

  1. 반볡횟수 tκ°€ ν• λ‹Ήλœλ‹€.
  2. μΌ€μ΄μŠ€λ§ˆλ‹€ 5 ~ 20자의 λžœλ€ν•œ λ¬Έμžμ—΄μ„ μƒμ„±ν•œλ‹€. 각 문자 사이엔 곡백이 ν¬ν•¨λœλ‹€.
  3. 곡백을 κ΅¬λΆ„μžλ‘œ λ¬Έμžμ—΄μ„ κ΅¬λΆ„ν•œλ‹€
    1. split μ‚¬μš©
    2. StringTokenizer μ‚¬μš©
  4. 총 μ†Œμš” μ‹œκ°„ 및 평균 μ†Œμš” μ‹œκ°„μ„ κ³„μ‚°ν•œλ‹€
  5. κ²°κ³Όλ₯Ό ν‘œμ‹œν•œλ‹€

μ†ŒμŠ€λŠ” μ•„λž˜μ™€ κ°™λ‹€.

JAVA

0import java.text.DecimalFormat;
1import java.util.Arrays;
2import java.util.Random;
3import java.util.StringTokenizer;
4
5/**
6 * 메인 클래슀
7 *
8 * @author RWB
9 * @since 2021.06.14 Mon 00:06:32
10 */
11public class Main
12{
13 /**
14 * 메인 ν•¨μˆ˜
15 *
16 * @param args: [String[]] λ§€κ°œλ³€μˆ˜
17 */
18 public static void main(String[] args)
19 {
20 int t = 10000;
21
22 long[] timer = { 0, 0 };
23
24 int[] sum = { 0, 0 };
25
26 for (int i = 0; i < t; i++)
27 {
28 int random = (int) ((Math.random() * (20 - 5)) + 5);
29
30 String text = getTestString(random);
31
32 // split 둜직 ----------------------------------------
33 long timeStart = System.nanoTime();
34
35 String[] a1 = useSplit(text);
36
37 long timeEnd = System.nanoTime() - timeStart;
38
39 sum[0] += a1.length;
40
41 timer[0] += timeEnd;
42
43 System.out.println(Arrays.toString(a1) + ": " + addComma(timeEnd) + "ns");
44 // split 둜직 ----------------------------------------
45
46 // StringTokenizer 둜직 ----------------------------------------
47 timeStart = System.nanoTime();
48
49 String[] a2 = useStringTokenizer(text);
50
51 timeEnd = System.nanoTime() - timeStart;
52
53 sum[1] += a2.length;
54
55 timer[1] += timeEnd;
56
57 System.out.println(Arrays.toString(a2) + ": " + addComma(timeEnd) + "ns");
58 // StringTokenizer 둜직 ----------------------------------------
59 }
60
61 System.out.println(addComma(t) + "개 데이터 κ·Έλ£Ή μˆ˜ν–‰");
62
63 System.out.println();
64
65 System.out.println("split κ²°κ³Ό");
66 System.out.println(" * 총 μ†Œμš”: " + addComma(timer[0]) + "ns");
67 System.out.println(" * 평균 μ†Œμš”: " + addComma((timer[0] / t)) + "ns");
68 System.out.println(" * λΆ„ν•΄ν•œ μš”μ†Œ: " + addComma(sum[0]) + "개");
69
70 System.out.println();
71
72 System.out.println("StringTokenizer κ²°κ³Ό");
73 System.out.println(" * 총 μ†Œμš”: " + addComma(timer[1]) + "ns");
74 System.out.println(" * 평균 μ†Œμš”: " + addComma((timer[1] / t)) + "ns");
75 System.out.println(" * λΆ„ν•΄ν•œ μš”μ†Œ: " + addComma(sum[1]) + "개");
76
77 System.out.println();
78
79 System.out.println("split " + (timer[0] == timer[1] ? "==" : (timer[0] > timer[1]) ? "<" : ">") + " StringTokenizer");
80 }
81
82 /**
83 * κ΅¬λΆ„λœ λ¬Έμžμ—΄ λ°˜ν™˜ ν•¨μˆ˜ (split)
84 *
85 * @param text: [String] λŒ€μƒ λ¬Έμžμ—΄
86 *
87 * @return [String[]] κ΅¬λΆ„λœ λ¬Έμžμ—΄
88 */
89 private static String[] useSplit(String text)
90 {
91 return text.split(" ");
92 }
93
94 /**
95 * κ΅¬λΆ„λœ λ¬Έμžμ—΄ λ°˜ν™˜ ν•¨μˆ˜ (StringTokenizer)
96 *
97 * @param text: [String] λŒ€μƒ λ¬Έμžμ—΄
98 *
99 * @return [String[]] κ΅¬λΆ„λœ λ¬Έμžμ—΄
100 */
101 private static String[] useStringTokenizer(String text)
102 {
103 StringTokenizer tokenizer = new StringTokenizer(text, " ");
104
105 int count = tokenizer.countTokens();
106
107 String[] result = new String[count];
108
109 for (int i = 0; i < count; i++)
110 {
111 result[i] = tokenizer.nextToken();
112 }
113
114 return result;
115 }
116
117 /**
118 * λ¬΄μž‘μœ„ λ¬Έμžμ—΄ λ°˜ν™˜ ν•¨μˆ˜
119 *
120 * @param n: [int] 문자 갯수
121 *
122 * @return [String] λ¬΄μž‘μœ„ 문자
123 */
124 private static String getTestString(int n)
125 {
126 Random random = new Random();
127
128 StringBuilder builder = new StringBuilder();
129
130 for (int i = 0; i < n; i++)
131 {
132 builder.append((char) ((random.nextInt(26)) + 97)).append(" ");
133 }
134
135 return builder.toString().trim();
136 }
137
138 /**
139 * 1000 λ‹¨μœ„ ꡬ뢄 숫자 λ°˜ν™˜ ν•¨μˆ˜
140 *
141 * @param num: [long] λŒ€μƒ 숫자
142 *
143 * @return [String] 1000 λ‹¨μœ„ ꡬ뢄 숫자
144 */
145 private static String addComma(long num)
146 {
147 DecimalFormat format = new DecimalFormat(",###");
148
149 return format.format(num);
150 }
151}

νšŸμˆ˜λ³„λ‘œ 10λ²ˆμ”© 돌린 κ²°κ³Όλ₯Ό μ•„λž˜μ˜ ν‘œλ‘œ μ •λ¦¬ν–ˆλ‹€.

ν…ŒμŠ€νŠΈ 횟수 split 총 μ†Œμš” StringTokenizer 총 μ†Œμš” 속도
1 80.3us 44.8us split < StringTokenizer
2 83.7us 46.2us split < StringTokenizer
3 136.6us 31.8us split < StringTokenizer
4 111.3us 40.4us split < StringTokenizer
5 93.4us 32.2us split < StringTokenizer
6 104.5us 28.7us split < StringTokenizer
7 40.1us 42.7us split > StringTokenizer
8 40.1us 42.7us split > StringTokenizer
9 104.7us 28.3us split < StringTokenizer
10 38.3us 29.2us split < StringTokenizer

ν•œ 번만 λ°˜λ³΅ν•  경우, 8:2둜 StringTokenizer이 μ••μŠΉν•œλ‹€.

ν…ŒμŠ€νŠΈ 횟수 split 총 μ†Œμš” StringTokenizer 총 μ†Œμš” 속도
1 1.12ms 0.602ms split < StringTokenizer
2 1.11ms 0.612ms split < StringTokenizer
3 1.06ms 0.562ms split < StringTokenizer
4 1.02ms 0.595ms split < StringTokenizer
5 1.ms 0.550ms split < StringTokenizer
6 1.16ms 0.651ms split < StringTokenizer
7 98ms 0.558ms split < StringTokenizer
8 1.11ms 0.627ms split < StringTokenizer
9 0.981ms 0.555ms split < StringTokenizer
10 1.23ms 0.666ms split < StringTokenizer

100λ²ˆμ„ λ°˜λ³΅ν•  λ•Œ μ—­μ‹œ 10:0으둜 StringTokenizer이 μ••μŠΉν•œλ‹€.

ν…ŒμŠ€νŠΈ 횟수 split 총 μ†Œμš” StringTokenizer 총 μ†Œμš” 속도
1 3.00ms 3.17ms split > StringTokenizer
2 2.53ms 2.71ms split > StringTokenizer
3 2.79ms 2.84ms split > StringTokenizer
4 2.53ms 2.67ms split > StringTokenizer
5 2.67ms 2.97ms split > StringTokenizer
6 2.58ms 2.87ms split > StringTokenizer
7 2.48ms 2.65ms split > StringTokenizer
8 2.69ms 3.01ms split > StringTokenizer
9 2.50ms 2.90ms split > StringTokenizer
10 2.62ms 2.94ms split > StringTokenizer

, 처럼 λŠμ–΄κ°€λ‹€κ°€ λœ¬κΈˆμ—†μ΄ 1000을 넣은 μ΄μœ λŠ”, μ΄μƒν•˜κ²Œ 일 땐 split이 μ••μŠΉν•œλ‹€.

ν…ŒμŠ€νŠΈ 횟수 split 총 μ†Œμš” StringTokenizer 총 μ†Œμš” 속도
1 9.91ms 9.27ms split < StringTokenizer
2 9.49ms 9.19ms split < StringTokenizer
3 9.02ms 8.61ms split < StringTokenizer
4 9.95ms 9.25ms split < StringTokenizer
5 9.03ms 8.87ms split < StringTokenizer
6 8.83ms 9.08ms split > StringTokenizer
7 9.14ms 8.68ms split < StringTokenizer
8 9.28ms 9.07ms split < StringTokenizer
9 9.49ms 9.66ms split > StringTokenizer
10 11.79ms 11.20ms split < StringTokenizer

λ‹€μ‹œ 8:2둜 StringTokenizer이 μ••μŠΉν•œλ‹€.

ν…ŒμŠ€νŠΈ 횟수 split 총 μ†Œμš” StringTokenizer 총 μ†Œμš” 속도
1 306.86ms 373.06ms split > StringTokenizer
2 287.26ms 262.05ms split < StringTokenizer
3 289.92ms 255.51ms split < StringTokenizer
4 272.43ms 267.96ms split < StringTokenizer
5 278.35ms 322.28ms split > StringTokenizer
6 285.23ms 264.57ms split < StringTokenizer
7 273.37ms 268.18ms split < StringTokenizer
8 278.65ms 264.34ms split < StringTokenizer
9 278.56ms 266.62ms split < StringTokenizer
10 306.00ms 256.56ms split < StringTokenizer

8:2둜 StringTokenizer이 μ••μŠΉν•œλ‹€.

μ΄λΌλŠ” νŠΉμˆ˜ν•œ 상황을 μ œμ™Έν•˜κ³ λŠ” 보편적으둜 StringTokenizerκ°€ μ„±λŠ₯이 더 μš°μˆ˜ν•˜λ‹€. μ €λŸ° ν˜„μƒμ΄ μ™œ λ°œμƒν•˜λŠ”μ§€ μ΄ν•΄λŠ” 잘 μ•ˆ λœλ‹€. λ¬Όλ‘  ν†΅κ³„λΌλŠ”κ²Œ μˆ«μžκ°€ 클 수둝 μ˜λ―Έκ°€ μ»€μ§€λ―€λ‘œ 10λ²ˆμ΄λΌλŠ” μž‘μ€ 횟수만으둜 단정짓긴 μ–΄λ ΅λ‹€.

νšŒμ‚¬ 컴퓨터(AMD Ryzen 2700X)μ—μ„œλŠ” λͺ¨λ“  μΌ€μ΄μŠ€μ—μ„œ StringTokenizer의 속도가 λΉ¨λžλ‹€. CPU에 따라 μ—°μ‚° κ²°κ³Όλ‚˜ 방식에 μ‘°κΈˆμ”© 차이가 μžˆμ„ 순 μžˆκ² λ‹€.

JAVA API에 μ˜ν•˜λ©΄, StringTokenizer은 ν•˜μœ„ ν˜Έν™˜μ„±μ„ 보μž₯ν•˜κΈ° μœ„ν•œ λ ˆκ±°μ‹œ 클래슀라고 ν•œλ‹€. JAVA APIλŠ” 가급적 StringTokenizer보닀 split λ‚΄μ§€λŠ” regex νŒ¨ν‚€μ§€λ₯Ό ν™œμš©ν•˜λ„λ‘ κΆŒκ³ ν•˜κ³  μžˆλ‹€.

원문
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.

κ²°λ‘  πŸ”—

ν‘œμ˜ 수치 상 StringTokenizerκ°€ split에 λΉ„ν•΄ μ΅œλŒ€ μ•½ 20% 정도 더 λΉ λ₯΄λ‹€. ν•˜μ§€λ§Œ JAVA APIμ—μ„œ 가급적 λ‹€λ₯Έ λŒ€μ²΄μ œλ₯Ό μ‚¬μš©ν•˜λ„λ‘ κΆŒκ³ ν•˜κ³  있고, 백만번의 연산에도 λ‹¨μœ„μ—μ„œ 움직인닀. μƒλŒ€μ μœΌλ‘  차이가 μžˆμ–΄λ„ 객관적인 μ§€ν‘œλ‘œ 봀을땐 별닀λ₯Έ 차이가 μ—†λŠ” μ…ˆ. λ¬Έμžμ—΄ λΆ„λ¦¬ν•˜μžκ³  μƒˆλ‘œμš΄ classλ₯Ό λ‹€λ£° 바에 κ·Έλƒ₯ λ¬Έμžμ—΄ 자체λ₯Ό λ‹€λ£¨λŠ” split을 μ‚¬μš©ν•˜λŠ” 게 더 효율적이라 μƒκ°ν•œλ‹€.