一个不涉及regex的非常简单的解决方案是在分隔符上执行字符串替换(假设分隔符为逗号):

string.replace(FullString, "," , "~,~")

在这里，您可以用适当的惟一分隔符替换tilda(~)。

然后，如果您对新的分隔符进行拆分，那么我相信您将得到所需的结果。

我喜欢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"]

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

我不知道Java API中是否存在这样做的现有函数(这并不是说它不存在)，但这是我自己的实现(一个或多个分隔符将作为单个令牌返回;如果你想让每个分隔符作为一个单独的标记返回，它将需要一些适应):

static String[] splitWithDelimiters(String s) {
    if (s == null || s.length() == 0) {
        return new String[0];
    }
    LinkedList<String> result = new LinkedList<String>();
    StringBuilder sb = null;
    boolean wasLetterOrDigit = !Character.isLetterOrDigit(s.charAt(0));
    for (char c : s.toCharArray()) {
        if (Character.isLetterOrDigit(c) ^ wasLetterOrDigit) {
            if (sb != null) {
                result.add(sb.toString());
            }
            sb = new StringBuilder();
            wasLetterOrDigit = !wasLetterOrDigit;
        }
        sb.append(c);
    }
    result.add(sb.toString());
    return result.toArray(new String[0]);
}

    String expression = "((A+B)*C-D)*E";
    expression = expression.replaceAll("\\+", "~+~");
    expression = expression.replaceAll("\\*", "~*~");
    expression = expression.replaceAll("-", "~-~");
    expression = expression.replaceAll("/+", "~/~");
    expression = expression.replaceAll("\\(", "~(~"); //also you can use [(] instead of \\(
    expression = expression.replaceAll("\\)", "~)~"); //also you can use [)] instead of \\)
    expression = expression.replaceAll("~~", "~");
    if(expression.startsWith("~")) {
        expression = expression.substring(1);
    }

    String[] expressionArray = expression.split("~");
    System.out.println(Arrays.toString(expressionArray));

快速回答:使用非物理边界，如\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|'|

有点太多了……: -)

我看了一下上面的答案，老实说，没有一个让我满意。您要做的实际上是模拟Perl分割功能。为什么Java不允许这样做，并且在某个地方有一个join()方法，这超出了我的范围，但我离题了。你甚至不需要专门的课程。它只是一个函数。运行这个示例程序:

一些早期的答案有过多的空检查，我最近写了一个回答这里的问题:

https://stackoverflow.com/users/18393/cletus

不管怎样，代码:

public class Split {
    public static List<String> split(String s, String pattern) {
        assert s != null;
        assert pattern != null;
        return split(s, Pattern.compile(pattern));
    }

    public static List<String> split(String s, Pattern pattern) {
        assert s != null;
        assert pattern != null;
        Matcher m = pattern.matcher(s);
        List<String> ret = new ArrayList<String>();
        int start = 0;
        while (m.find()) {
            ret.add(s.substring(start, m.start()));
            ret.add(m.group());
            start = m.end();
        }
        ret.add(start >= s.length() ? "" : s.substring(start));
        return ret;
    }

    private static void testSplit(String s, String pattern) {
        System.out.printf("Splitting '%s' with pattern '%s'%n", s, pattern);
        List<String> tokens = split(s, pattern);
        System.out.printf("Found %d matches%n", tokens.size());
        int i = 0;
        for (String token : tokens) {
            System.out.printf("  %d/%d: '%s'%n", ++i, tokens.size(), token);
        }
        System.out.println();
    }

    public static void main(String args[]) {
        testSplit("abcdefghij", "z"); // "abcdefghij"
        testSplit("abcdefghij", "f"); // "abcde", "f", "ghi"
        testSplit("abcdefghij", "j"); // "abcdefghi", "j", ""
        testSplit("abcdefghij", "a"); // "", "a", "bcdefghij"
        testSplit("abcdefghij", "[bdfh]"); // "a", "b", "c", "d", "e", "f", "g", "h", "ij"
    }
}