0
import java.util.Arrays;
1

2
/**
3
 * 메인 클래스
4
 *
5
 * @author RWB
6
 * @since 2021.06.13 Sun 22:50:57
7
 */
8
public 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
}

0
[A, B, C, D]

0
import java.util.Arrays;
1
import java.util.StringTokenizer;
2

3
/**
4
 * 메인 클래스
5
 *
6
 * @author RWB
7
 * @since 2021.06.13 Sun 23:48:14
8
 */
9
public 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
}

0
[A, B, C, D]

0
import java.text.DecimalFormat;
1
import java.util.Arrays;
2
import java.util.Random;
3
import java.util.StringTokenizer;
4

5
/**
6
 * 메인 클래스
7
 *
8
 * @author RWB
9
 * @since 2021.06.14 Mon 00:06:32
10
 */
11
public 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
}