我喜欢StringTokenizer的想法，因为它是可枚举的。 但它也是过时的，可以用String代替。split返回一个单调的String[](并且不包括分隔符)。

所以我实现了一个StringTokenizerEx，它是一个Iterable，它接受一个真正的regexp来分割字符串。

一个真正的regexp意味着它不是一个重复的'字符序列'来形成分隔符: 'o'只匹配'o'，并将'ooo'分成三个分隔符，其中有两个空字符串:

[o], '', [o], '', [o]

但是regexp o+在拆分“aooob”时将返回预期的结果

[], 'a', [ooo], 'b', []

使用StringTokenizerEx:

final StringTokenizerEx aStringTokenizerEx = new StringTokenizerEx("boo:and:foo", "o+");
final String firstDelimiter = aStringTokenizerEx.getDelimiter();
for(String aString: aStringTokenizerEx )
{
    // uses the split String detected and memorized in 'aString'
    final nextDelimiter = aStringTokenizerEx.getDelimiter();
}

该类的代码可以在DZone snippet中找到。

与通常的代码挑战响应(包含测试用例的自包含类)一样，复制粘贴它(在“src/test”目录中)并运行它。它的main()方法说明了不同的用法。

---

注:(2009年底编辑)

《Final Thoughts: Java Puzzler: Splitting hair》这篇文章很好地解释了String.split()中的奇怪行为。 乔希·布洛赫(Josh Bloch)甚至在回应那篇文章时评论道:

是的，这很痛苦。FWIW，这样做有一个很好的理由:与Perl的兼容性。 做这件事的人是Mike "madbot" McCloskey，他现在在谷歌和我们一起工作。Mike确保Java的正则表达式几乎通过了所有30K Perl正则表达式测试(并且运行得更快)。

谷歌公共库Guava还包含一个Splitter，它是:

使用更简单 由谷歌(而不是你)维护

所以它可能值得一看。从他们最初的粗略文件(pdf):

JDK有:

String[] pieces = "foo.bar".split("\\.");

如果你想要它所做的事情，使用它是很好的: -正则表达式 - result作为数组 -它处理空碎片的方式 小谜题:"，a，，b，".split("，")返回…

(a) "", "a", "", "b", ""
(b) null, "a", null, "b", null
(c) "a", null, "b"
(d) "a", "b"
(e) None of the above

答案:(e)以上都不是。

",a,,b,".split(",")
returns
"", "a", "", "b"

只跳过尾随空!(谁知道防止跳过的变通方法?这是一个有趣的…) 在任何情况下，我们的Splitter都更加灵活:默认行为很简单:

Splitter.on(',').split(" foo, ,bar, quux,")
--> [" foo", " ", "bar", " quux", ""]

如果您想要额外的功能，请提出要求!

Splitter.on(',')
.trimResults()
.omitEmptyStrings()
.split(" foo, ,bar, quux,")
--> ["foo", "bar", "quux"]

配置方法的顺序并不重要——在分割过程中，在检查空之前进行修整。

我来晚了，但回到最初的问题，为什么不使用搜索呢?

Pattern p = Pattern.compile("(?<=\\w)(?=\\W)|(?<=\\W)(?=\\w)");
System.out.println(Arrays.toString(p.split("'ab','cd','eg'")));
System.out.println(Arrays.toString(p.split("boo:and:foo")));

输出:

[', ab, ',', cd, ',', eg, ']
[boo, :, and, :, foo]

编辑:您在上面看到的是我运行该代码时命令行上出现的内容，但我现在看到它有点令人困惑。很难跟踪哪些逗号是结果的一部分，哪些是由Arrays.toString()添加的。SO的语法高亮显示也没有帮助。为了让突出显示与我一起工作而不是反对我，下面是我在源代码中声明这些数组的样子:

{ "'", "ab", "','", "cd", "','", "eg", "'" }
{ "boo", ":", "and", ":", "foo" }

我希望这更容易理解。谢谢你的提醒，@finnw。

如果负担得起，可以使用Java的replace(CharSequence target, CharSequence replacement)方法，并填充另一个分隔符以进行分割。 例子: 我想拆分字符串“boo:and:foo”，并将“:”放在它的右边。

String str = "boo:and:foo";
str = str.replace(":","newdelimiter:");
String[] tokens = str.split("newdelimiter");

重要提示:这只在你的字符串中没有进一步的“newdelimiter”时才有效!因此，这不是一个通解。 但是如果你知道一个CharSequence，你可以确定它永远不会出现在String中，这是一个非常简单的解决方案。

这个问题的一个微妙之处涉及到“前导分隔符”问题:如果要有一个组合的令牌和分隔符数组，则必须知道它是以令牌还是以分隔符开始的。你当然可以假设前导界限应该被丢弃，但这似乎是一个不合理的假设。你可能还想知道你是否有一个拖拽的delim。这将相应地设置两个布尔标志。

用Groovy编写，但Java版本应该相当明显:

            String tokenRegex = /[\p{L}\p{N}]+/ // a String in Groovy, Unicode alphanumeric
            def finder = phraseForTokenising =~ tokenRegex
            // NB in Groovy the variable 'finder' is then of class java.util.regex.Matcher
            def finderIt = finder.iterator() // extra method added to Matcher by Groovy magic
            int start = 0
            boolean leadingDelim, trailingDelim
            def combinedTokensAndDelims = [] // create an array in Groovy

            while( finderIt.hasNext() )
            {
                def token = finderIt.next()
                int finderStart = finder.start()
                String delim = phraseForTokenising[ start  .. finderStart - 1 ]
                // Groovy: above gets slice of String/array
                if( start == 0 ) leadingDelim = finderStart != 0
                if( start > 0 || leadingDelim ) combinedTokensAndDelims << delim
                combinedTokensAndDelims << token // add element to end of array
                start = finder.end()
            }
            // start == 0 indicates no tokens found
            if( start > 0 ) {
                // finish by seeing whether there is a trailing delim
                trailingDelim = start < phraseForTokenising.length()
                if( trailingDelim ) combinedTokensAndDelims << phraseForTokenising[ start .. -1 ]

                println( "leading delim? $leadingDelim, trailing delim? $trailingDelim, combined array:\n $combinedTokensAndDelims" )

            }

快速回答:使用非物理边界，如\b分割。我将尝试和实验，看看它是否有效(在PHP和JS中使用)。

这是可能的，也是一种工作，但可能会分裂太多。实际上，这取决于你想拆分的字符串和你需要的结果。提供更多细节，我们将更好地帮助您。

另一种方法是自己进行拆分，捕获分隔符(假设它是可变的)，然后将其添加到结果中。

我的快速测试:

String str = "'ab','cd','eg'";
String[] stra = str.split("\\b");
for (String s : stra) System.out.print(s + "|");
System.out.println();

结果:

'|ab|','|cd|','|eg|'|

有点太多了……: -)

下面是一个基于上面一些代码的groovy版本，以防有用。不管怎样，它很短。有条件地包括头部和尾部(如果它们不是空的)。最后一部分是演示/测试用例。

List splitWithTokens(str, pat) {
    def tokens=[]
    def lastMatch=0
    def m = str=~pat
    while (m.find()) {
      if (m.start() > 0) tokens << str[lastMatch..<m.start()]
      tokens << m.group()
      lastMatch=m.end()
    }
    if (lastMatch < str.length()) tokens << str[lastMatch..<str.length()]
    tokens
}

[['<html><head><title>this is the title</title></head>',/<[^>]+>/],
 ['before<html><head><title>this is the title</title></head>after',/<[^>]+>/]
].each { 
   println splitWithTokens(*it)
}