StringTokenizer在JAVA中拆分字符串是否更有效？

Question

我一直在解决SPOJ的反印迹系统问题

首先，我尝试使用String的split方法拆分输入字符串，提交后获得TLE

我的代码使用拆分方法

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.regex.Pattern;
import java.util.regex.Matcher;


class ABSYS {
    public static void main(String[] args) throws IOException {
        int t;
        String[] numArray = new String[2];
        String[] numArray2 = new String[2];
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        t = Integer.parseInt(reader.readLine());
        while(t > 0) {
            String input = reader.readLine();
            if(input.isEmpty()) {
                continue;
            }
            numArray = input.split("\\s{1}=\\s{1}");
            numArray2 = numArray[0].split("\\s{1}\\+\\s{1}");
            Pattern pattern = Pattern.compile("machula");
            Matcher matcher = pattern.matcher(numArray[1]);
            if(matcher.find()) {
                System.out.println(numArray[0] + " = " + (Integer.parseInt(numArray2[0]) + Integer.parseInt(numArray2[1])));
            }
            else {
                matcher = pattern.matcher(numArray2[0]);
                if(matcher.find()) {
                    System.out.println((Integer.parseInt(numArray[1]) - Integer.parseInt(numArray2[1])) + " + " + numArray2[1] + " = " + numArray[1]);
                }
                else {
                    System.out.println(numArray2[0] + " + " + (Integer.parseInt(numArray[1]) - Integer.parseInt(numArray2[0])) + " = " + numArray[1]);
                }
            }
            t--;
        }
    }
}

经过多次尝试，我失败了，无法使我的代码更省时

然后，今天我阅读了有关StringTokenizer ，并在我的代码中使用了它，然后就可以在spoj上找到它了

我的代码使用StringTokenizer

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.regex.Pattern;
import java.util.StringTokenizer;


class ABSYS {
    public static void main(String[] args) throws IOException {
        int t, a = 0, b = 0, c = 0, matchula = 0;
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        Pattern pattern = Pattern.compile("^(\\d)+$");
        t = Integer.parseInt(reader.readLine());
        while(t > 0) {
            String input = reader.readLine();
            if(input.isEmpty()) {
                continue;
            }
            StringTokenizer tokenizer = new StringTokenizer(input);
            String token = tokenizer.nextToken();
            if(pattern.matcher(token).matches()) {
                a = Integer.parseInt(token);
            }
            else
                matchula = 1;

            tokenizer.nextToken();
            token = tokenizer.nextToken();
            if(pattern.matcher(token).matches()) {
                System.out.println("b = " + token);
                b = Integer.parseInt(token);
            }
            else
                matchula = 2;

            tokenizer.nextToken();
            token = tokenizer.nextToken();
            if(pattern.matcher(token).matches()) {
                c = Integer.parseInt(token);
            }
            else
                matchula = 3;
            switch(matchula) {
                case 1: System.out.println((c-b) + " + " + b + " = " + c);
                        break;
                case 2: System.out.println(a + " + " + (c-a) + " = " + c);
                        break;
                case 3: System.out.println(a + " + " + b + " = " + (a+b));
                        break;
            }
            t--;
        }
    }
}

在JAVA Docs中，他们不鼓励使用StringTokenizer。

StringTokenizer是一个遗留类，出于兼容性原因而保留，尽管在新代码中不鼓励使用它。 建议任何寻求此功能的人改用String的split方法或java.util.regex包。

如Jason S所述，请在此处回答

如果我想用比单个字符更复杂的逻辑来标记字符串（例如，在\\ r \\ n上分割），则不能使用StringTokenizer，但可以使用String.split（）。

我的怀疑

1. 为什么会这样，即使我发现它更省时。
2. 不鼓励使用StringTokenizer的原因是什么？
3. 如果有人想像我的问题一样使用简单的正则表达式，那StringTokenizer比String.split()好吗？

Answer 1

String.split（）比StringTokenizer更灵活，更易于使用。 StringTokenizer早于Java对正则表达式的支持，而String.split（）支持正则表达式，这使它比StringTokenizer强大得多。 同样，String.split的结果是一个字符串数组，通常这是我们想要我们的结果的方式。 StringTokenizer确实比String.split（）快，但对于大多数实际目的而言，String.split（）足够快。

检查此问题的答案以获取更多详细信息扫描程序与StringTokenizer与String.Split

Answer 2

从技术上讲，总体而言， StringTokenizer比String.split()快，但将范围缩小到单个字符定界符时，它们的性能几乎相同。

查看String.split()源代码表明它检查了regex模式是否是一个简单的定界符，如果是，则执行老式的while循环来搜索String 。 在简单的测试中，使用单个char解析字符串时，我发现时间几乎没有区别。 这是StringTokenizer的典型用例。 因此，对于这么小的性能提升，确实不值得所有额外的代码。