我有一个多行字符串，由一组不同的分隔符分隔:
(Text1)(DelimiterA)(Text2)(DelimiterC)(Text3)(DelimiterB)(Text4)
我可以使用string将这个字符串分割成各个部分。分裂，但似乎我无法获得与分隔符正则表达式匹配的实际字符串。
换句话说，这就是我得到的结果:
Text1 Text2 Text3 Text4
这就是我想要的
Text1 DelimiterA Text2 DelimiterC Text3 DelimiterB Text4
JDK中是否有任何方法可以使用分隔符正则表达式分割字符串，但同时保留分隔符?
当前回答
这里有一个简单干净的实现，它与Pattern#split一致，并且适用于变长模式，后面的查看不支持，而且更容易使用。它类似于@cletus提供的解决方案。
public static String[] split(CharSequence input, String pattern) {
return split(input, Pattern.compile(pattern));
}
public static String[] split(CharSequence input, Pattern pattern) {
Matcher matcher = pattern.matcher(input);
int start = 0;
List<String> result = new ArrayList<>();
while (matcher.find()) {
result.add(input.subSequence(start, matcher.start()).toString());
result.add(matcher.group());
start = matcher.end();
}
if (start != input.length()) result.add(input.subSequence(start, input.length()).toString());
return result.toArray(new String[0]);
}
我在这里不做空检查，Pattern#split没有，为什么要我。我不喜欢结尾的if，但它是需要与Pattern#split保持一致的。否则，我将无条件地追加，如果输入字符串以模式结束，则结果的最后一个元素将是空字符串。
我转换为字符串[]与模式#分裂的一致性，我使用新字符串[0]而不是新字符串[result.size()]，看看这里为什么。
以下是我的测试:
@Test
public void splitsVariableLengthPattern() {
String[] result = Split.split("/foo/$bar/bas", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "/foo/", "$bar", "/bas" }, result);
}
@Test
public void splitsEndingWithPattern() {
String[] result = Split.split("/foo/$bar", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "/foo/", "$bar" }, result);
}
@Test
public void splitsStartingWithPattern() {
String[] result = Split.split("$foo/bar", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "", "$foo", "/bar" }, result);
}
@Test
public void splitsNoMatchesPattern() {
String[] result = Split.split("/foo/bar", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "/foo/bar" }, result);
}
其他回答
另一个使用正则表达式的候选解决方案。保留令牌顺序，正确匹配一行中相同类型的多个令牌。缺点是正则表达式有点讨厌。
package javaapplication2;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class JavaApplication2 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
String num = "58.5+variable-+98*78/96+a/78.7-3443*12-3";
// Terrifying regex:
// (a)|(b)|(c) match a or b or c
// where
// (a) is one or more digits optionally followed by a decimal point
// followed by one or more digits: (\d+(\.\d+)?)
// (b) is one of the set + * / - occurring once: ([+*/-])
// (c) is a sequence of one or more lowercase latin letter: ([a-z]+)
Pattern tokenPattern = Pattern.compile("(\\d+(\\.\\d+)?)|([+*/-])|([a-z]+)");
Matcher tokenMatcher = tokenPattern.matcher(num);
List<String> tokens = new ArrayList<>();
while (!tokenMatcher.hitEnd()) {
if (tokenMatcher.find()) {
tokens.add(tokenMatcher.group());
} else {
// report error
break;
}
}
System.out.println(tokens);
}
}
样例输出:
[58.5, +, variable, -, +, 98, *, 78, /, 96, +, a, /, 78.7, -, 3443, *, 12, -, 3]
我来晚了，但回到最初的问题，为什么不使用搜索呢?
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，但如果你找不到一个Split方法，我建议你自己做一个。
string[] mySplit(string s,string delimiter)
{
string[] result = s.Split(delimiter);
for(int i=0;i<result.Length-1;i++)
{
result[i] += delimiter; //this one would add the delimiter to each items end except the last item,
//you can modify it however you want
}
}
string[] res = mySplit(myString,myDelimiter);
它不是很优雅，但也可以。
这里有一个简单干净的实现，它与Pattern#split一致，并且适用于变长模式，后面的查看不支持，而且更容易使用。它类似于@cletus提供的解决方案。
public static String[] split(CharSequence input, String pattern) {
return split(input, Pattern.compile(pattern));
}
public static String[] split(CharSequence input, Pattern pattern) {
Matcher matcher = pattern.matcher(input);
int start = 0;
List<String> result = new ArrayList<>();
while (matcher.find()) {
result.add(input.subSequence(start, matcher.start()).toString());
result.add(matcher.group());
start = matcher.end();
}
if (start != input.length()) result.add(input.subSequence(start, input.length()).toString());
return result.toArray(new String[0]);
}
我在这里不做空检查，Pattern#split没有，为什么要我。我不喜欢结尾的if，但它是需要与Pattern#split保持一致的。否则，我将无条件地追加，如果输入字符串以模式结束，则结果的最后一个元素将是空字符串。
我转换为字符串[]与模式#分裂的一致性，我使用新字符串[0]而不是新字符串[result.size()]，看看这里为什么。
以下是我的测试:
@Test
public void splitsVariableLengthPattern() {
String[] result = Split.split("/foo/$bar/bas", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "/foo/", "$bar", "/bas" }, result);
}
@Test
public void splitsEndingWithPattern() {
String[] result = Split.split("/foo/$bar", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "/foo/", "$bar" }, result);
}
@Test
public void splitsStartingWithPattern() {
String[] result = Split.split("$foo/bar", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "", "$foo", "/bar" }, result);
}
@Test
public void splitsNoMatchesPattern() {
String[] result = Split.split("/foo/bar", "\\$\\w+");
Assert.assertArrayEquals(new String[] { "/foo/bar" }, result);
}
您希望使用查找，并在零宽度匹配时进行分割。下面是一些例子:
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 /看看
