我建议使用Pattern和Matcher，这几乎肯定会达到你想要的效果。你的正则表达式需要比你在String.split中使用的更复杂一些。

您希望使用查找，并在零宽度匹配时进行分割。下面是一些例子:

public class SplitNDump {
    static void dump(String[] arr) {
        for (String s : arr) {
            System.out.format("[%s]", s);
        }
        System.out.println();
    }
    public static void main(String[] args) {
        dump("1,234,567,890".split(","));
        // "[1][234][567][890]"
        dump("1,234,567,890".split("(?=,)"));   
        // "[1][,234][,567][,890]"
        dump("1,234,567,890".split("(?<=,)"));  
        // "[1,][234,][567,][890]"
        dump("1,234,567,890".split("(?<=,)|(?=,)"));
        // "[1][,][234][,][567][,][890]"

        dump(":a:bb::c:".split("(?=:)|(?<=:)"));
        // "[][:][a][:][bb][:][:][c][:]"
        dump(":a:bb::c:".split("(?=(?!^):)|(?<=:)"));
        // "[:][a][:][bb][:][:][c][:]"
        dump(":::a::::b  b::c:".split("(?=(?!^):)(?<!:)|(?!:)(?<=:)"));
        // "[:::][a][::::][b  b][::][c][:]"
        dump("a,bb:::c  d..e".split("(?!^)\\b"));
        // "[a][,][bb][:::][c][  ][d][..][e]"

        dump("ArrayIndexOutOfBoundsException".split("(?<=[a-z])(?=[A-Z])"));
        // "[Array][Index][Out][Of][Bounds][Exception]"
        dump("1234567890".split("(?<=\\G.{4})"));   
        // "[1234][5678][90]"

        // Split at the end of each run of letter
        dump("Boooyaaaah! Yippieeee!!".split("(?<=(?=(.)\\1(?!\\1))..)"));
        // "[Booo][yaaaa][h! Yipp][ieeee][!!]"
    }
}

是的，在最后一个模式中是三重嵌套断言。

相关问题

Java分裂正在吞噬我的角色。 你可以使用零宽度匹配正则表达式在字符串分割? 如何在Java中将CamelCase转换为人类可读的名称? 向后查找中的反向引用

另请参阅

regular-expressions.info /看看

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

有点太多了……: -)

如果你想保留字符，那么使用split方法，该方法存在.split()方法中的漏洞。

请看这个例子:

public class SplitExample {


    public static void main(String[] args) {  
        String str = "Javathomettt";  
        System.out.println("method 1");
        System.out.println("Returning words:");  
        String[] arr = str.split("t", 40);  
        for (String w : arr) {  
            System.out.println(w+"t");  
        }  
        System.out.println("Split array length: "+arr.length);  
        System.out.println("method 2");
        System.out.println(str.replaceAll("t", "\n"+"t"));
    }

如果负担得起，可以使用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中，这是一个非常简单的解决方案。

我不知道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]);
}