[JAVA] split vs StringTokenizer

⏰ 2021-06-13 (일) 16:56:01

screener

Table of Contents

  • 1. κ°œμš”






κ°œμš”

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

["A","B","C","D"]βˆ’>"ABCD"[ "A", "B", "C", "D" ] -> "A B C D"

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

ν…ŒμŠ€νŠΈ ν™˜κ²½

κ΅¬λΆ„λ‚΄μš©
μ–Έμ–΄
JAVA
OSWindows 10 64bit
CPUIntel i7-10700K
RAM32GB

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

λ©”μ†Œλ“œλ°˜ν™˜κ°’λ‚΄μš©
countTokenintν† ν°μ˜ 갯수
nextTokenStringλ‹€μŒ 토큰
hasMoreTokensbooleanλ‹€μŒ ν† ν°μ˜ 쑴재 유무

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=1t = 1
ν…ŒμŠ€νŠΈ 횟수split 총 μ†Œμš”StringTokenizer 총 μ†Œμš”μ†λ„
180.3us44.8ussplit < StringTokenizer
283.7us46.2ussplit < StringTokenizer
3136.6us31.8ussplit < StringTokenizer
4111.3us40.4ussplit < StringTokenizer
593.4us32.2ussplit < StringTokenizer
6104.5us28.7ussplit < StringTokenizer
740.1us42.7ussplit > StringTokenizer
840.1us42.7ussplit > StringTokenizer
9104.7us28.3ussplit < StringTokenizer
1038.3us29.2ussplit < StringTokenizer

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

  • t=100t = 100
ν…ŒμŠ€νŠΈ 횟수split 총 μ†Œμš”StringTokenizer 총 μ†Œμš”μ†λ„
11.12ms0.602mssplit < StringTokenizer
21.11ms0.612mssplit < StringTokenizer
31.06ms0.562mssplit < StringTokenizer
41.02ms0.595mssplit < StringTokenizer
51.ms0.550mssplit < StringTokenizer
61.16ms0.651mssplit < StringTokenizer
798ms0.558mssplit < StringTokenizer
81.11ms0.627mssplit < StringTokenizer
90.981ms0.555mssplit < StringTokenizer
101.23ms0.666mssplit < StringTokenizer

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

  • t=1,000t = 1,000
ν…ŒμŠ€νŠΈ 횟수split 총 μ†Œμš”StringTokenizer 총 μ†Œμš”μ†λ„
13.00ms3.17mssplit > StringTokenizer
22.53ms2.71mssplit > StringTokenizer
32.79ms2.84mssplit > StringTokenizer
42.53ms2.67mssplit > StringTokenizer
52.67ms2.97mssplit > StringTokenizer
62.58ms2.87mssplit > StringTokenizer
72.48ms2.65mssplit > StringTokenizer
82.69ms3.01mssplit > StringTokenizer
92.50ms2.90mssplit > StringTokenizer
102.62ms2.94mssplit > StringTokenizer

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

  • t=10,000t = 10,000
ν…ŒμŠ€νŠΈ 횟수split 총 μ†Œμš”StringTokenizer 총 μ†Œμš”μ†λ„
19.91ms9.27mssplit < StringTokenizer
29.49ms9.19mssplit < StringTokenizer
39.02ms8.61mssplit < StringTokenizer
49.95ms9.25mssplit < StringTokenizer
59.03ms8.87mssplit < StringTokenizer
68.83ms9.08mssplit > StringTokenizer
79.14ms8.68mssplit < StringTokenizer
89.28ms9.07mssplit < StringTokenizer
99.49ms9.66mssplit > StringTokenizer
1011.79ms11.20mssplit < StringTokenizer

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

  • t=1,000,000t = 1,000,000
ν…ŒμŠ€νŠΈ 횟수split 총 μ†Œμš”StringTokenizer 총 μ†Œμš”μ†λ„
1306.86ms373.06mssplit > StringTokenizer
2287.26ms262.05mssplit < StringTokenizer
3289.92ms255.51mssplit < StringTokenizer
4272.43ms267.96mssplit < StringTokenizer
5278.35ms322.28mssplit > StringTokenizer
6285.23ms264.57mssplit < StringTokenizer
7273.37ms268.18mssplit < StringTokenizer
8278.65ms264.34mssplit < StringTokenizer
9278.56ms266.62mssplit < StringTokenizer
10306.00ms256.56mssplit < StringTokenizer

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

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

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

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

κ²°λ‘ 

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


🏷️ νƒœκ·Έ
# JAVA(μžλ°”)
# String(λ¬Έμžμ—΄)
# split
# StringTokenizer

μ½μ–΄μ£Όμ…”μ„œ κ³ λ§ˆμ›Œμš”!

도움이 λ˜μ…¨λ‹€λ©΄, κ³΅κ°μ΄λ‚˜ λŒ“κΈ€μ„ λ‹¬μ•„μ£Όμ‹œλŠ” 건 μ–΄λ–€κ°€μš”?

λΈ”λ‘œκ·Έ μš΄μ˜μ— 큰 힘이 λ©λ‹ˆλ‹€.

https://hits.seeyoufarm.com/api/count/incr/badge.svg?count_bg=%23484848&icon=react.svg&icon_color=dodgerblue&title=view&title_bg=%23242424&url=https%3A%2F%2Fblog.itcode.dev%2Fposts%2F2021%2F06%2F14%2Fsplit-and-stringtokenizer