鼓舞于这篇文章和我有数十亿个字符串需要解析的事实，我尝试修改我的代码来接受StringTokenizer而不是String[]。
我与获得那种美味的x2性能提升之间唯一剩下的问题是，在进行解析时会遇到以下情况：
"dog,,cat".split(",")
//output: ["dog","","cat"]
StringTokenizer("dog,,cat")
// nextToken() = "dog"
// nextToken() = "cat"
你只是在以逗号作为分词依据吗？如果是的话，我会编写自己的分词器-它可能会比更通用的StringTokenizer更加高效，因为后者可以查找多个标记，并且您可以使其按照您想要的方式运行。对于这样一个简单的用例，可以使用简单的实现。
如果有用的话，甚至可以实现Iterable<String>并获得增强型for循环支持和具有强类型的枚举而不是StringTokenizer提供的支持。如果需要帮助编写此类程序，请告诉我-这实际上应该不难。
此外，在跳离现有解决方案之前，我建议您尝试在实际数据上运行性能测试。你有没有想过你的执行时间有多少实际上被花费在 String.split 上？我知道你要解析很多字符串，但如果你之后要使用它们进行任何重要的操作，我会认为那将比分割更重要。
StringTokenizer类后，我无法找到满足返回["dog", "", "cat"]要求的方法。此外，StringTokenizer类仅用于兼容性原因，鼓励使用String.split。从StringTokenizer的API规范中可以看出：
由于问题在于
StringTokenizer是一个遗留类，为了兼容性而保留，虽然它的使用在新代码中被不推荐。建议任何寻求此功能的人使用String的split方法或java.util.regex包。
String.split方法的表现较差，我们需要找到替代方案。
注意：我说"表现较差"是因为很难确定每种情况下StringTokenizer都优于String.split方法。此外，在许多情况下，除非字符串的分词确实是由适当的分析确定的应用程序的瓶颈，否则我认为这最终将成为过早的优化，如果有的话，我倾向于编写有意义且易于理解的代码，而不是进行优化。
现在，根据当前的需求，可能自己编写分词器并不太困难。
自己编写分词器！
下面是我编写的一个简单的分词器。需要注意的是，没有速度优化，也没有错误检查来防止超出字符串的末尾 - 这只是一个快速而简单的实现：
class MyTokenizer implements Iterable<String>, Iterator<String> {
String delim = ",";
String s;
int curIndex = 0;
int nextIndex = 0;
boolean nextIsLastToken = false;
public MyTokenizer(String s, String delim) {
this.s = s;
this.delim = delim;
}
public Iterator<String> iterator() {
return this;
}
public boolean hasNext() {
nextIndex = s.indexOf(delim, curIndex);
if (nextIsLastToken)
return false;
if (nextIndex == -1)
nextIsLastToken = true;
return true;
}
public String next() {
if (nextIndex == -1)
nextIndex = s.length();
String token = s.substring(curIndex, nextIndex);
curIndex = nextIndex + 1;
return token;
}
public void remove() {
throw new UnsupportedOperationException();
}
}
MyTokenizer将使用一个String作为分词器，另一个String作为分隔符，并使用String.indexOf方法来查找分隔符。通过String.substring方法产生令牌。
我认为通过在char[]级别而不是String级别上处理字符串可能会有一些性能改进。但我将把这个任务留给读者自行完成。
该类还实现了Iterable和Iterator以利用Java 5中引入的for-each循环结构。 StringTokenizer是一个Enumerator，不支持for-each结构。
它是否更快？
为了找出这是否更快，我编写了一个程序来比较以下四种方法的速度：
StringTokenizer。MyTokenizer。String.split。Pattern.compile 预编译正则表达式。在这四种方法中，字符串 "dog,,cat" 被分成了多个标记。虽然比较中包含了 StringTokenizer，但应注意它不会返回所需的结果 ["dog", "", "cat]。
为了足够地显示出这些方法之间的差异，对标记进行了 100 万次重复操作。
用于简单基准测试的代码如下：
long st = System.currentTimeMillis();
for (int i = 0; i < 1e6; i++) {
StringTokenizer t = new StringTokenizer("dog,,cat", ",");
while (t.hasMoreTokens()) {
t.nextToken();
}
}
System.out.println(System.currentTimeMillis() - st);
st = System.currentTimeMillis();
for (int i = 0; i < 1e6; i++) {
MyTokenizer mt = new MyTokenizer("dog,,cat", ",");
for (String t : mt) {
}
}
System.out.println(System.currentTimeMillis() - st);
st = System.currentTimeMillis();
for (int i = 0; i < 1e6; i++) {
String[] tokens = "dog,,cat".split(",");
for (String t : tokens) {
}
}
System.out.println(System.currentTimeMillis() - st);
st = System.currentTimeMillis();
Pattern p = Pattern.compile(",");
for (int i = 0; i < 1e6; i++) {
String[] tokens = p.split("dog,,cat");
for (String t : tokens) {
}
}
System.out.println(System.currentTimeMillis() - st);
结果
测试使用Java SE 6 (build 1.6.0_12-b04)运行，结果如下：
运行1 运行2 运行3 运行4 运行5
----- ----- ----- ----- -----
StringTokenizer 172 188 187 172 172
MyTokenizer 234 234 235 234 235
String.split 1172 1156 1171 1172 1156
Pattern.compile 906 891 891 907 906
因此，从有限的测试和仅五次运行可以看出，StringTokenizer确实是最快的，但MyTokenizer排名第二。然后，String.split是最慢的，而预编译的正则表达式比split方法稍快。
与任何小基准测试一样，它可能不太代表实际情况，因此应该对结果持怀疑态度。
String token = s.substring(curIndex, nextIndex);
curIndex = nextIndex + delim.length();
return token; } - Juan Carlos Blanco MartínezScanner sc = new Scanner("dog,,cat");
sc.useDelimiter(",");
while (sc.hasNext()) {
System.out.println(sc.next());
}
给出：
dog
cat
根据需要进行分词的字符串类型，您可以基于String.indexOf()编写自己的分割器。您还可以创建一个多核解决方案，以进一步提高性能，因为字符串的分词是相互独立的。每个核心处理100个字符串的批次。使用String.split()或其他方法。
public static List<String> find(String test, char c) {
List<String> list = new Vector<String>();
start;
int i=0;
while (i<=test.length()) {
int start = i;
while (i<test.length() && test.charAt(i)!=c) {
i++;
}
list.add(test.substring(start, i));
i++;
}
return list;
}
public static void split(String test, char c) {
int i=0;
while (i<=test.length()) {
int start = i;
while (i<test.length() && test.charAt(i)!=c) {
i++;
}
String s = test.substring(start,i);
// do something with the string here
i++;
}
}
嗯，你能做的最快的事情就是手动遍历字符串，例如
List<String> split(String s) {
List<String> out= new ArrayList<String>();
int idx = 0;
int next = 0;
while ( (next = s.indexOf( ',', idx )) > -1 ) {
out.add( s.substring( idx, next ) );
idx = next + 1;
}
if ( idx < s.length() ) {
out.add( s.substring( idx ) );
}
return out;
}
这个（非正式测试）看起来比split快两倍。然而，这种迭代方式有点危险，例如它会在转义逗号上中断，如果您最终需要处理它（因为您的十亿个字符串列表有3个转义逗号），那么到时候您可能会失去一些速度优势。
最终，这可能不值得麻烦。
Splitter。
我将其与coobird测试进行了比较，并得到以下结果：
StringTokenizer 104
Google Guava Splitter 142
String.split 446
正则表达式 299
TOKEN { <CAT: "cat"> , <DOG:"gog"> }
input: (cat() | dog())*
cat: <CAT>
{
animals.add(new Animal("Cat"));
}
dog: <DOG>
{
animals.add(new Animal("Dog"));
}