entityMap|blocks|key|fkfi7|text|我不太了解Java，但是如果你找不到一个能做到这一点的Split方法，我建议你自己做一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|f71dm|string[]+mySplit(string+s,string+delimiter)
{
++++string[]+result+=+s.Split(delimiter);
++++for(int+i=0;i|code-block|syntax|javascript|70lo0|Its+not+too+elegant,+but+it'll+do.^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

I don't know Java too well, but if you can't find a Split method that does that, I suggest you just make your own.

<pre><code>string[] mySplit(string s,string delimiter)
{
 string[] result = s.Split(delimiter);
 for(int i=0;i&lt;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);
</code></pre>

Its not too elegant, but it'll do.

entityMap|blocks|key|2i7j|text|快速回答:使用像\b这样的非物理界限来拆分。我将尝试并实验看看它是否工作(在PHP和JS中使用)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3bql6|这是可能的，也是一种工作，但可能会分裂太多。实际上，这取决于您要拆分的字符串和所需的结果。请提供更多详细信息，我们将帮助您做得更好。|68j15|另一种方法是进行自己的拆分，捕获分隔符(假设它是可变的)，然后将其添加到结果中。|6mjpk|我的快速测试：|5rp0q|String+str+=+"'ab','cd','eg'";
String[]+stra+=+str.split("\\b");
for+(String+s+:+stra)+System.out.print(s+%2B+"%7C");
System.out.println();|code-block|syntax|javascript|1lppc|结果：|edfpo|'%7Cab%7C','%7Ccd%7C','%7Ceg%7C'%7C|31aih|有点太多了..。:-)^0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|T|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|U|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|V|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|W|9|@]|A|@]|B|$]]|$2|I|4|J|6|K|8|X|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|7|8|Y|9|@]|A|@]|B|$]]|$2|P|4|Q|6|K|8|Z|9|@]|A|@]|B|$L|M]]|$2|R|4|S|6|7|8|10|9|@]|A|@]|B|$]]]]

Fast answer: use non physical bounds like \b to split. I will try and experiment to see if it works (used that in PHP and JS).

It is possible, and kind of work, but might split too much. Actually, it depends on the string you want to split and the result you need. Give more details, we will help you better.

Another way is to do your own split, capturing the delimiter (supposing it is variable) and adding it afterward to the result.

My quick test:

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

Result:

<pre><code>'|ab|','|cd|','|eg|'|
</code></pre>

A bit too much... :-)

entityMap|blocks|key|4bk0f|text|我不知道Java+API中有没有这样做的现有函数(这并不是说它不存在)，但这里是我自己的实现(一个或多个分隔符将作为单个令牌返回；如果您希望每个分隔符作为单独的令牌返回，则需要进行一些调整)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|eb1j5|static+String[]+splitWithDelimiters(String+s)+{
++++if+(s+==+null+%7C%7C+s.length()+==+0)+{
++++++++return+new+String[0];
++++}
++++LinkedList+result+=+new+LinkedList();
++++StringBuilder+sb+=+null;
++++boolean+wasLetterOrDigit+=+!Character.isLetterOrDigit(s.charAt(0));
++++for+(char+c+:+s.toCharArray())+{
++++++++if+(Character.isLetterOrDigit(c)+%5E+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]);
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

I don't know of an existing function in the Java API that does this (which is not to say it doesn't exist), but here's my own implementation (one or more delimiters will be returned as a single token; if you want each delimiter to be returned as a separate token, it will need a bit of adaptation):

<pre><code>static String[] splitWithDelimiters(String s) {
 if (s == null || s.length() == 0) {
 return new String[0];
 }
 LinkedList&lt;String&gt; result = new LinkedList&lt;String&gt;();
 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]);
}
</code></pre>

entityMap|blocks|key|a4k30|text|我喜欢StringTokenizer的想法，因为它是可枚举的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ee7e|但它也已过时，并被返回无聊字符串的String.split所取代..。|b37u1|所以我实现了一个StringTokenizerEx，它是一个迭代器，它需要一个真正的正则表达式来拆分字符串。|efals|真正的regexp意味着它不是重复形成分隔符的“字符序列”：|9u04d|'o‘将只与'o’匹配，并将'ooo‘拆分为三个分隔符，其中包含两个空字符串：|309ir|[o],+'',+[o],+'',+[o]|code-block|syntax|javascript|ba64j|但是当拆分"aooob“时，正则表达式o%2B会返回预期的结果。|5pvp9|[],+'a',+[ooo],+'b',+[]|9bv3s|要使用此StringTokenizerEx，请执行以下操作：|1q05p|final+StringTokenizerEx+aStringTokenizerEx+=+new+StringTokenizerEx("boo:and:foo",+"o%2B");
final+String+firstDelimiter+=+aStringTokenizerEx.getDelimiter();
for(String+aString:+aStringTokenizerEx+)
{
++++//+uses+the+split+String+detected+and+memorized+in+'aString'
++++final+nextDelimiter+=+aStringTokenizerEx.getDelimiter();
}|dbtro|这个类的代码可以在DZone代码片段..。|4sb9f|像往常一样，代码-挑战响应(一个包含测试用例的自包含类)，复制-粘贴(在'src/test‘目录中)和运行它..。它的main()方法说明了不同的用法。|1lf4v|注：(2009年底编辑)|18n|文章最后的想法:+Java+Puzzler:挑拨离间做了一项很好的工作，解释了String.split()..。|2f4n4|Josh+Bloch甚至在回应那篇文章时评论道：|5e4qt|是的，这是一种痛苦。顺便说一句，这样做有一个非常好的理由:与Perl的兼容性。|a0nca|做这件事的人是“狂人”Mike+McCloskey，他现在和我们一起在谷歌工作。Mike确保Java的正则表达式几乎通过了30K+Perl正则表达式测试中的每一个(并且运行得更快)。|5c3e|5187j|谷歌通用库Guava还包含一个拆分器，它是：|cb309|使用更简单|bt21n|由Google维护(而不是由您维护)|9q8sh|因此，它可能值得一试。从他们的初始粗略文档(pdf)|b988r|JDK具有以下特性：|ifjk|String[]+pieces+=+"foo.bar".split("\\.");|6gmm|如果您想要的正是它所做的事情，那么使用它是很好的：-正则表达式-结果作为一个数组-它处理空块的方式|b3g3s|迷你拼图："，a，，b，".split("，")返回...|cobh0|(a)+"",+"a",+"",+"b",+""
(b)+null,+"a",+null,+"b",+null
(c)+"a",+null,+"b"
(d)+"a",+"b"
(e)+None+of+the+above|fckmk|答：(e)以上都不是。|rueq|",a,,b,".split(",")
returns
"",+"a",+"",+"b"|ejhuc|仅跳过尾随的空格！(谁知道防止跳过的解决方法？这是一个有趣的问题...)|8dcuj|在任何情况下，我们的拆分器都更加灵活:默认行为过于简单：|7k33g|Splitter.on(',').split("+foo,+,bar,+quux,")
-->+["+foo",+"+",+"bar",+"+quux",+""]|7gffa|如果你想要额外的功能，那就提出来吧！|ck3i8|Splitter.on(',')
.trimResults()
.omitEmptyStrings()
.split("+foo,+,bar,+quux,")
-->+["foo",+"bar",+"quux"]|d9dhn|配置方法的顺序并不重要--在拆分期间，在检查是否为空之前进行修剪。^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|2A|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|2B|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|2C|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|2D|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|2E|9|@]|A|@]|B|$]]|$2|K|4|L|6|M|8|2F|9|@]|A|@]|B|$N|O]]|$2|P|4|Q|6|7|8|2G|9|@]|A|@]|B|$]]|$2|R|4|S|6|M|8|2H|9|@]|A|@]|B|$N|O]]|$2|T|4|U|6|7|8|2I|9|@]|A|@]|B|$]]|$2|V|4|W|6|M|8|2J|9|@]|A|@]|B|$N|O]]|$2|X|4|Y|6|7|8|2K|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|2L|9|@]|A|@]|B|$]]|$2|11|4|12|6|7|8|2M|9|@]|A|@]|B|$]]|$2|13|4|14|6|7|8|2N|9|@]|A|@]|B|$]]|$2|15|4|16|6|7|8|2O|9|@]|A|@]|B|$]]|$2|17|4|18|6|7|8|2P|9|@]|A|@]|B|$]]|$2|19|4|1A|6|7|8|2Q|9|@]|A|@]|B|$]]|$2|1B|4|-4|6|7|8|2R|9|@]|A|@]|B|$]]|$2|1C|4|1D|6|7|8|2S|9|@]|A|@]|B|$]]|$2|1E|4|1F|6|7|8|2T|9|@]|A|@]|B|$]]|$2|1G|4|1H|6|7|8|2U|9|@]|A|@]|B|$]]|$2|1I|4|1J|6|7|8|2V|9|@]|A|@]|B|$]]|$2|1K|4|1L|6|7|8|2W|9|@]|A|@]|B|$]]|$2|1M|4|1N|6|M|8|2X|9|@]|A|@]|B|$N|O]]|$2|1O|4|1P|6|7|8|2Y|9|@]|A|@]|B|$]]|$2|1Q|4|1R|6|7|8|2Z|9|@]|A|@]|B|$]]|$2|1S|4|1T|6|M|8|30|9|@]|A|@]|B|$N|O]]|$2|1U|4|1V|6|7|8|31|9|@]|A|@]|B|$]]|$2|1W|4|1X|6|M|8|32|9|@]|A|@]|B|$N|O]]|$2|1Y|4|1Z|6|7|8|33|9|@]|A|@]|B|$]]|$2|20|4|21|6|7|8|34|9|@]|A|@]|B|$]]|$2|22|4|23|6|M|8|35|9|@]|A|@]|B|$N|O]]|$2|24|4|25|6|7|8|36|9|@]|A|@]|B|$]]|$2|26|4|27|6|M|8|37|9|@]|A|@]|B|$N|O]]|$2|28|4|29|6|7|8|38|9|@]|A|@]|B|$]]]]

I like the idea of StringTokenizer because it is Enumerable. 
But it is also obsolete, and replace by String.split which return a boring String[] (and does not includes the delimiters).

So I implemented a StringTokenizerEx which is an Iterable, and which takes a true regexp to split a string.

A true regexp means it is not a 'Character sequence' repeated to form the delimiter: 
'o' will only match 'o', and split 'ooo' into three delimiter, with two empty string inside:

<pre><code>[o], '', [o], '', [o]
</code></pre>

But the regexp o+ will return the expected result when splitting "aooob"

<pre><code>[], 'a', [ooo], 'b', []
</code></pre>

To use this StringTokenizerEx:

<pre><code>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();
}
</code></pre>

The code of this class is available at <a href="http://snippets.dzone.com/posts/show/6450" rel="noreferrer">DZone Snippets</a>.

As usual for a <a href="https://stackoverflow.com/questions/172184">code-challenge</a> response (one self-contained class with test cases included), copy-paste it (in a 'src/test' directory) and run it. Its main() method illustrates the different usages.

<hr>

Note: (late 2009 edit)

The article <a href="http://konigsberg.blogspot.com/2009/11/final-thoughts-java-puzzler-splitting.html" rel="noreferrer">Final Thoughts: Java Puzzler: Splitting Hairs</a> does a good work explaning the bizarre behavior in <code>String.split()</code>. 
Josh Bloch even commented in response to that article:

<blockquote>
 Yes, this is a pain. FWIW, it was done for a very good reason: compatibility with Perl. 
 The guy who did it is Mike "madbot" McCloskey, who now works with us at Google. Mike made sure that Java's regular expressions passed virtually every one of the 30K Perl regular expression tests (and ran faster).
</blockquote>

The Google <a href="http://code.google.com/p/guava-libraries/" rel="noreferrer">common-library Guava</a> contains also a Splitter which is:

<ul>
<li>simpler to use</li>
<li>maintained by Google (and not by you)</li>
</ul>

So it may worth being checked out. From their <a href="http://guava-libraries.googlecode.com/files/Guava_a_sketchy_overview.pdf" rel="noreferrer">initial rough documentation (pdf)</a>:

<blockquote>
 JDK has this:
</blockquote>

<pre><code>String[] pieces = "foo.bar".split("\\.");
</code></pre>

<blockquote>
 It's fine to use this if you want exactly what it does:
 - regular expression
 - result as an array
 - its way of handling empty pieces
 
 Mini-puzzler: ",a,,b,".split(",") returns...
</blockquote>

<pre><code>(a) "", "a", "", "b", ""
(b) null, "a", null, "b", null
(c) "a", null, "b"
(d) "a", "b"
(e) None of the above
</code></pre>

<blockquote>
 Answer: (e) None of the above.
</blockquote>

<pre><code>",a,,b,".split(",")
returns
"", "a", "", "b"
</code></pre>

<blockquote>
 Only trailing empties are skipped! (Who knows the workaround to prevent the skipping? It's a fun one...)
 
 In any case, our Splitter is simply more flexible: The default behavior is simplistic:
</blockquote>

<pre><code>Splitter.on(',').split(" foo, ,bar, quux,")
--&gt; [" foo", " ", "bar", " quux", ""]
</code></pre>

<blockquote>
 If you want extra features, ask for them!
</blockquote>

<pre><code>Splitter.on(',')
.trimResults()
.omitEmptyStrings()
.split(" foo, ,bar, quux,")
--&gt; ["foo", "bar", "quux"]
</code></pre>

<blockquote>
 Order of config methods doesn't matter -- during splitting, trimming happens before checking for empties.
</blockquote>

entityMap|blocks|key|4798e|text|import+java.util.regex.*;
import+java.util.LinkedList;

public+class+Splitter+{
++++private+static+final+Pattern+DEFAULT_PATTERN+=+Pattern.compile("\\s%2B");

++++private+Pattern+pattern;
++++private+boolean+keep_delimiters;

++++public+Splitter(Pattern+pattern,+boolean+keep_delimiters)+{
++++++++this.pattern+=+pattern;
++++++++this.keep_delimiters+=+keep_delimiters;
++++}
++++public+Splitter(String+pattern,+boolean+keep_delimiters)+{
++++++++this(Pattern.compile(pattern==null?"":pattern),+keep_delimiters);
++++}
++++public+Splitter(Pattern+pattern)+{+this(pattern,+true);+}
++++public+Splitter(String+pattern)+{+this(pattern,+true);+}
++++public+Splitter(boolean+keep_delimiters)+{+this(DEFAULT_PATTERN,+keep_delimiters);+}
++++public+Splitter()+{+this(DEFAULT_PATTERN);+}

++++public+String[]+split(String+text)+{
++++++++if+(text+==+null)+{
++++++++++++text+=+"";
++++++++}

++++++++int+last_match+=+0;
++++++++LinkedList+splitted+=+new+LinkedList();

++++++++Matcher+m+=+this.pattern.matcher(text);

++++++++while+(m.find())+{

++++++++++++splitted.add(text.substring(last_match,m.start()));

++++++++++++if+(this.keep_delimiters)+{
++++++++++++++++splitted.add(m.group());
++++++++++++}

++++++++++++last_match+=+m.end();
++++++++}

++++++++splitted.add(text.substring(last_match));

++++++++return+splitted.toArray(new+String[splitted.size()]);
++++}

++++public+static+void+main(String[]+argv)+{
++++++++if+(argv.length+!=+2)+{
++++++++++++System.err.println("Syntax:+java+Splitter++");
++++++++++++return;
++++++++}

++++++++Pattern+pattern+=+null;
++++++++try+{
++++++++++++pattern+=+Pattern.compile(argv[0]);
++++++++}
++++++++catch+(PatternSyntaxException+e)+{
++++++++++++System.err.println(e);
++++++++++++return;
++++++++}

++++++++Splitter+splitter+=+new+Splitter(pattern);

++++++++String+text+=+argv[1];
++++++++int+counter+=+1;
++++++++for+(String+part+:+splitter.split(text))+{
++++++++++++System.out.printf("Part+%25d:+\"%25s\"\n",+counter%2B%2B,+part);
++++++++}
++++}
}

/*
++++Example:
++++>+java+Splitter+"\W%2B"+"Hello+World!"
++++Part+1:+"Hello"
++++Part+2:+"+"
++++Part+3:+"World"
++++Part+4:+"!"
++++Part+5:+""
*/|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|hhf4|我真的不喜欢另一种方式，在前面和后面都有一个空的元素。分隔符通常不在字符串的开头或结尾，因此最常见的结果是浪费了两个很好的数组槽。|unstyled|7uh7c|编辑：|1vjn8|修复了限制情况。测试用例的注释源可以在这里找到：|85kt9|http://snippets.dzone.com/posts/show/6453^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$C|D]]|$2|E|4|F|6|G|8|O|9|@]|A|@]|B|$]]|$2|H|4|I|6|G|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|G|8|Q|9|@]|A|@]|B|$]]|$2|L|4|M|6|G|8|R|9|@]|A|@]|B|$]]]]

<pre><code>import java.util.regex.*;
import java.util.LinkedList;

public class Splitter {
 private static final Pattern DEFAULT_PATTERN = Pattern.compile("\\s+");

 private Pattern pattern;
 private boolean keep_delimiters;

 public Splitter(Pattern pattern, boolean keep_delimiters) {
 this.pattern = pattern;
 this.keep_delimiters = keep_delimiters;
 }
 public Splitter(String pattern, boolean keep_delimiters) {
 this(Pattern.compile(pattern==null?"":pattern), keep_delimiters);
 }
 public Splitter(Pattern pattern) { this(pattern, true); }
 public Splitter(String pattern) { this(pattern, true); }
 public Splitter(boolean keep_delimiters) { this(DEFAULT_PATTERN, keep_delimiters); }
 public Splitter() { this(DEFAULT_PATTERN); }

 public String[] split(String text) {
 if (text == null) {
 text = "";
 }

 int last_match = 0;
 LinkedList&lt;String&gt; splitted = new LinkedList&lt;String&gt;();

 Matcher m = this.pattern.matcher(text);

 while (m.find()) {

 splitted.add(text.substring(last_match,m.start()));

 if (this.keep_delimiters) {
 splitted.add(m.group());
 }

 last_match = m.end();
 }

 splitted.add(text.substring(last_match));

 return splitted.toArray(new String[splitted.size()]);
 }

 public static void main(String[] argv) {
 if (argv.length != 2) {
 System.err.println("Syntax: java Splitter &lt;pattern&gt; &lt;text&gt;");
 return;
 }

 Pattern pattern = null;
 try {
 pattern = Pattern.compile(argv[0]);
 }
 catch (PatternSyntaxException e) {
 System.err.println(e);
 return;
 }

 Splitter splitter = new Splitter(pattern);

 String text = argv[1];
 int counter = 1;
 for (String part : splitter.split(text)) {
 System.out.printf("Part %d: \"%s\"\n", counter++, part);
 }
 }
}

/*
 Example:
 &gt; java Splitter "\W+" "Hello World!"
 Part 1: "Hello"
 Part 2: " "
 Part 3: "World"
 Part 4: "!"
 Part 5: ""
*/
</code></pre>

I don't really like the other way, where you get an empty element in front and back. A delimiter is usually not at the beginning or at the end of the string, thus you most often end up wasting two good array slots.

Edit: Fixed limit cases. Commented source with test cases can be found here: <a href="http://snippets.dzone.com/posts/show/6453" rel="noreferrer">http://snippets.dzone.com/posts/show/6453</a>

entityMap|blocks|key|anjp9|text|我来晚了，但回到最初的问题，为什么不直接使用lookarounds呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ehvrf|Pattern+p+=+Pattern.compile("(?<=\\w)(?=\\W)%7C(?<=\\W)(?=\\w)");
System.out.println(Arrays.toString(p.split("'ab','cd','eg'")));
System.out.println(Arrays.toString(p.split("boo:and:foo")));|code-block|syntax|javascript|6knmj|输出：|37o78|[',+ab,+',',+cd,+',',+eg,+']
[boo,+:,+and,+:,+foo]|2ijdd|编辑:您在上面看到的是当我运行该代码时出现在命令行上的内容，但我现在看到它有点令人困惑。很难跟踪哪些逗号是结果的一部分，哪些逗号是由Arrays.toString()..。所以语法高亮也无济于事。希望让高亮显示起作用使用我不反对我，以下是这些数组的外观我在源代码中声明了它们：|2s68p|{+"'",+"ab",+"','",+"cd",+"','",+"eg",+"'"+}
{+"boo",+":",+"and",+":",+"foo"+}|35j0e|我希望这更容易读懂。谢谢你的提醒，@finnw。^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|R|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|S|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|T|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|U|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|V|9|@]|A|@]|B|$]]|$2|N|4|O|6|E|8|W|9|@]|A|@]|B|$F|G]]|$2|P|4|Q|6|7|8|X|9|@]|A|@]|B|$]]]]

I got here late, but returning to the original question, why not just use lookarounds?

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

output:

<pre><code>[', ab, ',', cd, ',', eg, ']
[boo, :, and, :, foo]
</code></pre>

EDIT: What you see above is what appears on the command line when I run that code, but I now see that it's a bit confusing. It's difficult to keep track of which commas are part of the result and which were added by <code>Arrays.toString()</code>. SO's syntax highlighting isn't helping either. In hopes of getting the highlighting to work with me instead of against me, here's how those arrays would look it I were declaring them in source code:

<pre><code>{ "'", "ab", "','", "cd", "','", "eg", "'" }
{ "boo", ":", "and", ":", "foo" }
</code></pre>

I hope that's easier to read. Thanks for the heads-up, @finnw.

entityMap|blocks|key|7jq5q|text|下面是一个简单、干净的实现，它与Pattern#split和可变长度的模式一起工作，这看起来不支持，而且它更容易使用。它类似于解决方案由@cletus提供。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|cdnvc|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+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]);
}|code-block|syntax|javascript|u4fi|我这里不做空检查，Pattern#split不会，为什么我会。我不喜欢if，但为了与Pattern#split。否则，我将无条件地追加，如果输入字符串以模式结尾，则会导致空字符串作为结果的最后一个元素。|e8r8o|为了与String[]保持一致，我将其转换为Pattern#split，我使用new+String[0]而不是new+String[result.size()]，请参阅|71sp9|这里原因。|fmk5q|以下是我的测试：|o4nn|@Test
public+void+splitsVariableLengthPattern()+{
++++String[]+result+=+Split.split("/foo/$bar/bas",+"\\$\\w%2B");
++++Assert.assertArrayEquals(new+String[]+{+"/foo/",+"$bar",+"/bas"+},+result);
}

@Test
public+void+splitsEndingWithPattern()+{
++++String[]+result+=+Split.split("/foo/$bar",+"\\$\\w%2B");
++++Assert.assertArrayEquals(new+String[]+{+"/foo/",+"$bar"+},+result);
}

@Test
public+void+splitsStartingWithPattern()+{
++++String[]+result+=+Split.split("$foo/bar",+"\\$\\w%2B");
++++Assert.assertArrayEquals(new+String[]+{+"",+"$foo",+"/bar"+},+result);
}

@Test
public+void+splitsNoMatchesPattern()+{
++++String[]+result+=+Split.split("/foo/bar",+"\\$\\w%2B");
++++Assert.assertArrayEquals(new+String[]+{+"/foo/bar"+},+result);
}^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|R|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|S|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|T|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|U|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|V|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|W|9|@]|A|@]|B|$]]|$2|P|4|Q|6|E|8|X|9|@]|A|@]|B|$F|G]]]]

I had a look at the above answers and honestly none of them I find satisfactory. What you want to do is essentially mimic the Perl split functionality. Why Java doesn't allow this and have a join() method somewhere is beyond me but I digress. You don't even need a class for this really. Its just a function. Run this sample program:

Some of the earlier answers have excessive null-checking, which I recently wrote a response to a question here:

<a href="https://stackoverflow.com/users/18393/cletus">https://stackoverflow.com/users/18393/cletus</a>

Anyway, the code:

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

 public static List&lt;String&gt; split(String s, Pattern pattern) {
 assert s != null;
 assert pattern != null;
 Matcher m = pattern.matcher(s);
 List&lt;String&gt; ret = new ArrayList&lt;String&gt;();
 int start = 0;
 while (m.find()) {
 ret.add(s.substring(start, m.start()));
 ret.add(m.group());
 start = m.end();
 }
 ret.add(start &gt;= 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&lt;String&gt; 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"
 }
}
</code></pre>

entityMap|blocks|key|f94cr|text|我看了上面的答案，老实说，没有一个是令我满意的。您想要做的实际上是模拟Perl拆分功能。为什么Java不允许这样做，并在某个地方使用join()方法，这超出了我的理解，但我离题了。你甚至不需要一个类来做这件事。这只是一个函数。运行以下示例程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|708t7|一些早期的答案有过多的空检查，我最近在这里写了一个问题的回复：https://stackoverflow.com/users/18393/cletus|1mras|不管怎样，代码如下：|5v7i8|public+class+Split+{
++++public+static+List+split(String+s,+String+pattern)+{
++++++++assert+s+!=+null;
++++++++assert+pattern+!=+null;
++++++++return+split(s,+Pattern.compile(pattern));
++++}

++++public+static+List+split(String+s,+Pattern+pattern)+{
++++++++assert+s+!=+null;
++++++++assert+pattern+!=+null;
++++++++Matcher+m+=+pattern.matcher(s);
++++++++List+ret+=+new+ArrayList();
++++++++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+'%25s'+with+pattern+'%25s'%25n",+s,+pattern);
++++++++List+tokens+=+split(s,+pattern);
++++++++System.out.printf("Found+%25d+matches%25n",+tokens.size());
++++++++int+i+=+0;
++++++++for+(String+token+:+tokens)+{
++++++++++++System.out.printf("++%25d/%25d:+'%25s'%25n",+%2B%2Bi,+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"
++++}
}|code-block|syntax|javascript^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|M|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|N|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|O|9|@]|A|@]|B|$J|K]]]]

entityMap|blocks|key|26meg|text|我认为这是不可能的String#split，但您可以使用StringTokenizer，尽管这不允许您将分隔符定义为正则表达式，但只能将其定义为一类一位数字符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5ejf9|new+StringTokenizer("Hello,+world.+Hi!",+",.!",+true);+//+true+for+returnDelims|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

I don't think it is possible with <code>String#split</code>, but you can use a <code>StringTokenizer</code>, though that won't allow you to define your delimiter as a regex, but only as a class of single-digit characters:

<pre><code>new StringTokenizer("Hello, world. Hi!", ",.!", true); // true for returnDelims
</code></pre>

entityMap|blocks|key|d3ukg|text|我建议使用Pattern和Matcher，它们几乎肯定会实现您想要的结果。您的正则表达式需要比在String.split中使用的要复杂一些。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

I suggest using Pattern and Matcher, which will almost certainly achieve what you want. Your regular expression will need to be somewhat more complicated than what you are using in String.split.

entityMap|blocks|key|dql6s|text|一个不涉及正则表达式的非常天真的解决方案是在分隔符上执行字符串替换，如下所示(假设用逗号代替分隔符)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8eph1|string.replace(FullString,+","+,+"~,~")|code-block|syntax|javascript|cnmgs|其中，您可以将tilda+(~)替换为适当的唯一分隔符。|ehcvj|然后，如果你对新的分隔符进行拆分，那么我相信你会得到想要的结果。^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|O|9|@]|A|@]|B|$]]]]

A very naive solution, that doesn't involve regex would be to perform a string replace on your delimiter along the lines of (assuming comma for delimiter):

<pre><code>string.replace(FullString, "," , "~,~")
</code></pre>

Where you can replace tilda (~) with an appropriate unique delimiter.

Then if you do a split on your new delimiter then i believe you will get the desired result.

entityMap|blocks|key|a8582|text|如果您负担得起，可以使用Java的replace(CharSequence目标，CharSequence替换)方法，并填充另一个分隔符以进行拆分。例如:我想拆分字符串"boo:+and+:foo“，并将”：“保留在其右侧的字符串中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d1hno|String+str+=+"boo:and:foo";
str+=+str.replace(":","newdelimiter:");
String[]+tokens+=+str.split("newdelimiter");|code-block|syntax|javascript|2i6h9|重要提示:只有当字符串中没有进一步的"newdelimiter“时，这才有效！因此，它不是一个通用的解决方案。但是如果你知道一个CharSequence，你可以确定它永远不会出现在字符串中，这是一个非常简单的解决方案。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

If you can afford, use Java's replace(CharSequence target, CharSequence replacement) method and fill in another delimiter to split with.
Example:
I want to split the string "boo:and:foo" and keep ':' at its righthand String.

<pre><code>String str = "boo:and:foo";
str = str.replace(":","newdelimiter:");
String[] tokens = str.split("newdelimiter");
</code></pre>

Important note: This only works if you have no further "newdelimiter" in your String! Thus, it is not a general solution. 
But if you know a CharSequence of which you can be sure that it will never appear in the String, this is a very simple solution.

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://stackoverflow.com/questions/2819933/java-split-is-eating-my-characters/|1|https://stackoverflow.com/questions/2406633/can-you-use-zero-width-matching-regex-in-string-split|2|https://stackoverflow.com/questions/2559759/how-do-i-convert-camelcase-into-human-readable-names-in-java|3|https://stackoverflow.com/questions/2734977/backreferences-in-lookbehind|4|http://www.regular-expressions.info/lookaround.html|blocks|key|5h24h|text|您希望使用lookarounds，并在零宽度匹配上拆分。下面是一些示例：|unstyled|depth|inlineStyleRanges|entityRanges|1agbv|public+class+SplitNDump+{
++++static+void+dump(String[]+arr)+{
++++++++for+(String+s+:+arr)+{
++++++++++++System.out.format("[%25s]",+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("(?<=,)%7C(?=,)"));
++++++++//+"[1][,][234][,][567][,][890]"

++++++++dump(":a:bb::c:".split("(?=:)%7C(?<=:)"));
++++++++//+"[][:][a][:][bb][:][:][c][:]"
++++++++dump(":a:bb::c:".split("(?=(?!%5E):)%7C(?<=:)"));
++++++++//+"[:][a][:][bb][:][:][c][:]"
++++++++dump(":::a::::b++b::c:".split("(?=(?!%5E):)(?|code-block|syntax|javascript|5gdo4|And+yes,+that+is+triply-nested+assertion+there+in+the+last+pattern.|offset|length|style|CODE|cu5d1|Related+questions|header-three|BOLD|2t3ki|Java+split+is+eating+my+characters.|unordered-list-item|651gb|Can+you+use+zero-width+matching+regex+in+String+split?|b3l5f|How+do+I+convert+CamelCase+into+human-readable+names+in+Java?|c4hqu|Backreferences+in+lookbehind|cf379|See+also|eda0n|regular-expressions.info/Lookarounds^0|0|0|0|1V|0|0|H|0|H|0|0|Z|0|Z|0|0|0|1I|0|1I|1|0|0|1P|0|1P|2|0|0|S|0|S|3|0|0|8|0|8|0|0|10|0|10|4^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]|B|$2|3|4|5|6|$7|C]]|D|$2|3|4|5|6|$7|E]]|F|$2|3|4|5|6|$7|G]]]|H|@$I|J|K|L|2|M|N|1I|O|@]|P|@]|6|$]]|$I|Q|K|R|2|S|N|1J|O|@]|P|@]|6|$T|U]]|$I|V|K|W|2|M|N|1K|O|@$X|1L|Y|1M|Z|10]]|P|@]|6|$]]|$I|11|K|12|2|13|N|1N|O|@$X|1O|Y|1P|Z|14]|$X|1Q|Y|1R|Z|10]]|P|@]|6|$]]|$I|15|K|16|2|17|N|1S|O|@$X|1T|Y|1U|Z|10]]|P|@$X|1V|Y|1W|I|1X]]|6|$]]|$I|18|K|19|2|17|N|1Y|O|@$X|1Z|Y|20|Z|10]]|P|@$X|21|Y|22|I|23]]|6|$]]|$I|1A|K|1B|2|17|N|24|O|@$X|25|Y|26|Z|10]]|P|@$X|27|Y|28|I|29]]|6|$]]|$I|1C|K|1D|2|17|N|2A|O|@$X|2B|Y|2C|Z|10]]|P|@$X|2D|Y|2E|I|2F]]|6|$]]|$I|1E|K|1F|2|13|N|2G|O|@$X|2H|Y|2I|Z|14]|$X|2J|Y|2K|Z|10]]|P|@]|6|$]]|$I|1G|K|1H|2|17|N|2L|O|@$X|2M|Y|2N|Z|10]]|P|@$X|2O|Y|2P|I|2Q]]|6|$]]]]

You want to use lookarounds, and split on zero-width matches. Here are some examples:

<pre><code>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("(?&lt;=,)")); 
 // "[1,][234,][567,][890]"
 dump("1,234,567,890".split("(?&lt;=,)|(?=,)"));
 // "[1][,][234][,][567][,][890]"

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

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

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

And yes, that is triply-nested assertion there in the last pattern.

<h3>Related questions</h3>

<ul>
<li><a href="https://stackoverflow.com/questions/2819933/java-split-is-eating-my-characters/">Java split is eating my characters.</a></li>
<li><a href="https://stackoverflow.com/questions/2406633/can-you-use-zero-width-matching-regex-in-string-split">Can you use zero-width matching regex in String split?</a></li>
<li><a href="https://stackoverflow.com/questions/2559759/how-do-i-convert-camelcase-into-human-readable-names-in-java">How do I convert CamelCase into human-readable names in Java?</a></li>
<li><a href="https://stackoverflow.com/questions/2734977/backreferences-in-lookbehind">Backreferences in lookbehind</a></li>
</ul>

<h3>See also</h3>

<ul>
<li><a href="http://www.regular-expressions.info/lookaround.html" rel="noreferrer">regular-expressions.info/Lookarounds</a></li>
</ul>

entityMap|blocks|key|693a8|text|我知道这是一个非常-非常古老的问题，答案也被接受了。但我仍然想对原来的问题提出一个非常简单的答案。考虑以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3h025|String+str+=+"Hello-World:How\nAre+You&doing";
inputs+=+str.split("(?!%5E)\\b");
for+(int+i=0;+i|code-block|syntax|javascript|1caum|OUTPUT:|offset|length|style|BOLD|dvii2|a[0]+=+"Hello"
a[1]+=+"-"
a[2]+=+"World"
a[3]+=+":"
a[4]+=+"How"
a[5]+=+"
"
a[6]+=+"Are"
a[7]+=+"+"
a[8]+=+"You"
a[9]+=+"&"
a[10]+=+"doing"|btqus|I+am+just+using+word+boundary+\b+to+delimit+the+words+except+when+it+is+start+of+text.|ITALIC^0|0|0|0|7|0|0|1I|6^^$0|$]|1|@$2|3|4|5|6|7|8|S|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|T|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|U|9|@$J|V|K|W|L|M]]|A|@]|B|$]]|$2|N|4|O|6|E|8|X|9|@]|A|@]|B|$F|G]]|$2|P|4|Q|6|7|8|Y|9|@$J|Z|K|10|L|R]]|A|@]|B|$]]]]

I know this is a very-very old question and answer has also been accepted. But still I would like to submit a very simple answer to original question. Consider this code:

<pre><code>String str = "Hello-World:How\nAre You&amp;doing";
inputs = str.split("(?!^)\\b");
for (int i=0; i&lt;inputs.length; i++) {
 System.out.println("a[" + i + "] = \"" + inputs[i] + '"');
}
</code></pre>

OUTPUT:

<pre><code>a[0] = "Hello"
a[1] = "-"
a[2] = "World"
a[3] = ":"
a[4] = "How"
a[5] = "
"
a[6] = "Are"
a[7] = " "
a[8] = "You"
a[9] = "&amp;"
a[10] = "doing"
</code></pre>

I am just using word boundary <code>\b</code> to delimit the words except when it is start of text.

entityMap|blocks|key|cissf|text|已调整Pattern.split()要将匹配的模式包括到列表中，请执行以下操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3iihb|添加|1ohkn|//+add+match+to+the+list
++++++++matchList.add(input.subSequence(start,+end).toString());|code-block|syntax|javascript|2ntqq|完整源代码|8qug0|public+static+String[]+inclusiveSplit(String+input,+String+re,+int+limit)+{
++++int+index+=+0;
++++boolean+matchLimited+=+limit+>+0;
++++ArrayList+matchList+=+new+ArrayList();

++++Pattern+pattern+=+Pattern.compile(re);
++++Matcher+m+=+pattern.matcher(input);

++++//+Add+segments+before+each+match+found
++++while+(m.find())+{
++++++++int+end+=+m.end();
++++++++if+(!matchLimited+%7C%7C+matchList.size()+<+limit+-+1)+{
++++++++++++int+start+=+m.start();
++++++++++++String+match+=+input.subSequence(index,+start).toString();
++++++++++++matchList.add(match);
++++++++++++//+add+match+to+the+list
++++++++++++matchList.add(input.subSequence(start,+end).toString());
++++++++++++index+=+end;
++++++++}+else+if+(matchList.size()+==+limit+-+1)+{+//+last+one
++++++++++++String+match+=+input.subSequence(index,+input.length())
++++++++++++++++++++.toString();
++++++++++++matchList.add(match);
++++++++++++index+=+end;
++++++++}
++++}

++++//+If+no+match+was+found,+return+this
++++if+(index+==+0)
++++++++return+new+String[]+{+input.toString()+};

++++//+Add+remaining+segment
++++if+(!matchLimited+%7C%7C+matchList.size()+<+limit)
++++++++matchList.add(input.subSequence(index,+input.length()).toString());

++++//+Construct+result
++++int+resultSize+=+matchList.size();
++++if+(limit+==+0)
++++++++while+(resultSize+>+0+&&+matchList.get(resultSize+-+1).equals(""))
++++++++++++resultSize--;
++++String[]+result+=+new+String[resultSize];
++++return+matchList.subList(0,+resultSize).toArray(result);
}^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|O|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|P|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|Q|9|@]|A|@]|B|$]]|$2|L|4|M|6|G|8|R|9|@]|A|@]|B|$H|I]]]]

Tweaked <a href="http://download.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html#split%28java.lang.CharSequence,%20int%29" rel="nofollow">Pattern.split()</a> to include matched pattern to the list

Added 

<pre><code>// add match to the list
 matchList.add(input.subSequence(start, end).toString());
</code></pre>

Full source

<pre><code>public static String[] inclusiveSplit(String input, String re, int limit) {
 int index = 0;
 boolean matchLimited = limit &gt; 0;
 ArrayList&lt;String&gt; matchList = new ArrayList&lt;String&gt;();

 Pattern pattern = Pattern.compile(re);
 Matcher m = pattern.matcher(input);

 // Add segments before each match found
 while (m.find()) {
 int end = m.end();
 if (!matchLimited || matchList.size() &lt; limit - 1) {
 int start = m.start();
 String match = input.subSequence(index, start).toString();
 matchList.add(match);
 // add match to the list
 matchList.add(input.subSequence(start, end).toString());
 index = end;
 } else if (matchList.size() == limit - 1) { // last one
 String match = input.subSequence(index, input.length())
 .toString();
 matchList.add(match);
 index = end;
 }
 }

 // If no match was found, return this
 if (index == 0)
 return new String[] { input.toString() };

 // Add remaining segment
 if (!matchLimited || matchList.size() &lt; limit)
 matchList.add(input.subSequence(index, input.length()).toString());

 // Construct result
 int resultSize = matchList.size();
 if (limit == 0)
 while (resultSize &gt; 0 &amp;&amp; matchList.get(resultSize - 1).equals(""))
 resultSize--;
 String[] result = new String[resultSize];
 return matchList.subList(0, resultSize).toArray(result);
}
</code></pre>

entityMap|blocks|key|ct697|text|这是一个非常幼稚且低效的解决方案，它使用nevertheless.Use在字符串上拆分两次，然后将两个数组连接起来|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d7uo9|String+temp[]=str.split("\\W");
String+temp2[]=str.split("\\w%7C%7C\\s");
int+i=0;
for(String+string:temp)
System.out.println(string);
String+temp3[]=new+String[temp.length-1];
for(String+string:temp2)
{
++++++++System.out.println(string);
++++++++if((string.equals("")!=true)&&(string.equals("\\s")!=true))
++++++++{
++++++++++++++++temp3[i]=string;
++++++++++++++++i%2B%2B;
++++++++}
//++++++System.out.println(temp.length);
//++++++System.out.println(temp2.length);
}
System.out.println(temp3.length);
String[]+temp4=new+String[temp.length%2Btemp3.length];
int+j=0;
for(i=0;i|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

An extremely naive and inefficient solution which works nevertheless.Use split twice on the string and then concatenate the two arrays

<pre><code>String temp[]=str.split("\\W");
String temp2[]=str.split("\\w||\\s");
int i=0;
for(String string:temp)
System.out.println(string);
String temp3[]=new String[temp.length-1];
for(String string:temp2)
{
 System.out.println(string);
 if((string.equals("")!=true)&amp;&amp;(string.equals("\\s")!=true))
 {
 temp3[i]=string;
 i++;
 }
// System.out.println(temp.length);
// System.out.println(temp2.length);
}
System.out.println(temp3.length);
String[] temp4=new String[temp.length+temp3.length];
int j=0;
for(i=0;i&lt;temp.length;i++)
{
 temp4[j]=temp[i];
 j=j+2;
}
j=1;
for(i=0;i&lt;temp3.length;i++)
{
 temp4[j]=temp3[i];
 j+=2;
}
for(String s:temp4)
System.out.println(s);
</code></pre>

entityMap|blocks|key|9qp6r|text|这是一个基于上面一些代码的groovy版本，以防万一。不管怎么说，它很短。有条件地包括头部和尾部(如果它们不为空)。最后一部分是演示/测试用例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bv3gg|List+splitWithTokens(str,+pat)+{
++++def+tokens=[]
++++def+lastMatch=0
++++def+m+=+str=~pat
++++while+(m.find())+{
++++++if+(m.start()+>+0)+tokens+<<+str[lastMatch..this+is+the+title',/<[%5E>]%2B>/],
+['beforethis+is+the+titleafter',/<[%5E>]%2B>/]
].each+{+
+++println+splitWithTokens(*it)
}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Here's a groovy version based on some of the code above, in case it helps. It's short, anyway. Conditionally includes the head and tail (if they are not empty). The last part is a demo/test case.

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

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

entityMap|blocks|key|pkmg|text|将第三个参数作为"true“传递。它还将返回分隔符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|259j1|StringTokenizer(String+str,+String+delimiters,+true);|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Pass the 3rd aurgument as "true". It will return delimiters as well.

<pre><code>StringTokenizer(String str, String delimiters, true);
</code></pre>

entityMap|blocks|key|6do4b|text|我也会发布我的工作版本(第一个版本与Markus非常相似)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7m61u|public+static+String[]+splitIncludeDelimeter(String+regex,+String+text){
++++List+list+=+new+LinkedList<>();
++++Matcher+matcher+=+Pattern.compile(regex).matcher(text);

++++int+now,+old+=+0;
++++while(matcher.find()){
++++++++now+=+matcher.end();
++++++++list.add(text.substring(old,+now));
++++++++old+=+now;
++++}

++++if(list.size()+==+0)
++++++++return+new+String[]{text};

++++//adding+rest+of+a+text+as+last+element
++++String+finalElement+=+text.substring(old);
++++list.add(finalElement);

++++return+list.toArray(new+String[list.size()]);
}|code-block|syntax|javascript|22ekn|这是第二个解决方案，它比第一个方案快50%25：|e6ub6|public+static+String[]+splitIncludeDelimeter2(String+regex,+String+text){
++++List+list+=+new+LinkedList<>();
++++Matcher+matcher+=+Pattern.compile(regex).matcher(text);

++++StringBuffer+stringBuffer+=+new+StringBuffer();
++++while(matcher.find()){
++++++++matcher.appendReplacement(stringBuffer,+matcher.group());
++++++++list.add(stringBuffer.toString());
++++++++stringBuffer.setLength(0);+//clear+buffer
++++}

++++matcher.appendTail(stringBuffer);+///dodajemy+reszte++ciagu
++++list.add(stringBuffer.toString());

++++return+list.toArray(new+String[list.size()]);
}^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

I will post my working versions also(first is really similar to Markus).

<pre><code>public static String[] splitIncludeDelimeter(String regex, String text){
 List&lt;String&gt; list = new LinkedList&lt;&gt;();
 Matcher matcher = Pattern.compile(regex).matcher(text);

 int now, old = 0;
 while(matcher.find()){
 now = matcher.end();
 list.add(text.substring(old, now));
 old = now;
 }

 if(list.size() == 0)
 return new String[]{text};

 //adding rest of a text as last element
 String finalElement = text.substring(old);
 list.add(finalElement);

 return list.toArray(new String[list.size()]);
}
</code></pre>

And here is second solution and its round 50% faster than first one:

<pre><code>public static String[] splitIncludeDelimeter2(String regex, String text){
 List&lt;String&gt; list = new LinkedList&lt;&gt;();
 Matcher matcher = Pattern.compile(regex).matcher(text);

 StringBuffer stringBuffer = new StringBuffer();
 while(matcher.find()){
 matcher.appendReplacement(stringBuffer, matcher.group());
 list.add(stringBuffer.toString());
 stringBuffer.setLength(0); //clear buffer
 }

 matcher.appendTail(stringBuffer); ///dodajemy reszte ciagu
 list.add(stringBuffer.toString());

 return list.toArray(new String[list.size()]);
}
</code></pre>

entityMap|blocks|key|674hd|text|String+expression+=+"((A%2BB)*C-D)*E";
++++expression+=+expression.replaceAll("\\%2B",+"~%2B~");
++++expression+=+expression.replaceAll("\\*",+"~*~");
++++expression+=+expression.replaceAll("-",+"~-~");
++++expression+=+expression.replaceAll("/%2B",+"~/~");
++++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));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript^0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$C|D]]]]

<pre><code> 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));
</code></pre>

entityMap|blocks|key|e2f3u|text|另一个使用正则表达式的候选解决方案。保留令牌顺序，在一行中正确匹配多个相同类型的令牌。缺点是正则表达式有点令人讨厌。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|a9msf|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%2Bvariable-%2B98*78/96%2Ba/78.7-3443*12-3";

++++++++//+Terrifying+regex:
++++++++//++(a)%7C(b)%7C(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%2B(\.\d%2B)?)
++++++++//+++(b)+is+one+of+the+set+%2B+*+/+-+occurring+once:+([%2B*/-])
++++++++//+++(c)+is+a+sequence+of+one+or+more+lowercase+latin+letter:+([a-z]%2B)
++++++++Pattern+tokenPattern+=+Pattern.compile("(\\d%2B(\\.\\d%2B)?)%7C([%2B*/-])%7C([a-z]%2B)");
++++++++Matcher+tokenMatcher+=+tokenPattern.matcher(num);

++++++++List+tokens+=+new+ArrayList<>();

++++++++while+(!tokenMatcher.hitEnd())+{
++++++++++++if+(tokenMatcher.find())+{
++++++++++++++++tokens.add(tokenMatcher.group());
++++++++++++}+else+{
++++++++++++++++//+report+error
++++++++++++++++break;
++++++++++++}
++++++++}

++++++++System.out.println(tokens);
++++}
}|code-block|syntax|javascript|abl3v|示例输出：|9qvip|[58.5,+%2B,+variable,+-,+%2B,+98,+*,+78,+/,+96,+%2B,+a,+/,+78.7,+-,+3443,+*,+12,+-,+3]^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

Another candidate solution using a regex. Retains token order, correctly matches multiple tokens of the same type in a row. The downside is that the regex is kind of nasty.

<pre><code>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&lt;String&gt; tokens = new ArrayList&lt;&gt;();

 while (!tokenMatcher.hitEnd()) {
 if (tokenMatcher.find()) {
 tokens.add(tokenMatcher.group());
 } else {
 // report error
 break;
 }
 }

 System.out.println(tokens);
 }
}
</code></pre>

Sample output:

<pre><code>[58.5, +, variable, -, +, 98, *, 78, /, 96, +, a, /, 78.7, -, 3443, *, 12, -, 3]
</code></pre>

entityMap|blocks|key|976uf|text|这个问题中的一个微妙之处涉及“前导分隔符”问题:如果要使用标记和分隔符的组合数组，则必须知道它是以标记还是分隔符开头。当然，您可以假设应该丢弃一个领先的delim，但这似乎是一个不合理的假设。你可能还想知道你是否有一个尾随的神志不清。这将相应地设置两个布尔标志。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|837b|用Groovy编写，但Java版本应该相当明显：|221bu|String+tokenRegex+=+/[\p{L}\p{N}]%2B/+//+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+%7C%7C+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"+)

++++++++++++}|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

One of the subtleties in this question involves the "leading delimiter" question: if you are going to have a combined array of tokens and delimiters you have to know whether it starts with a token or a delimiter. You could of course just assume that a leading delim should be discarded but this seems an unjustified assumption. You might also want to know whether you have a trailing delim or not. This sets two boolean flags accordingly.

Written in Groovy but a Java version should be fairly obvious:

<pre><code> 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 &gt; 0 || leadingDelim ) combinedTokensAndDelims &lt;&lt; delim
 combinedTokensAndDelims &lt;&lt; token // add element to end of array
 start = finder.end()
 }
 // start == 0 indicates no tokens found
 if( start &gt; 0 ) {
 // finish by seeing whether there is a trailing delim
 trailingDelim = start &lt; phraseForTokenising.length()
 if( trailingDelim ) combinedTokensAndDelims &lt;&lt; phraseForTokenising[ start .. -1 ]

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

 }
</code></pre>

entityMap|blocks|key|c7k59|text|如果你想保留字符，那么使用带有漏洞的split方法.split()方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ftk1a|请参阅此示例：|1b1re|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%2B"t");++
++++++++}++
++++++++System.out.println("Split+array+length:+"%2Barr.length);++
++++++++System.out.println("method+2");
++++++++System.out.println(str.replaceAll("t",+"\n"%2B"t"));
++++}|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

If you want keep character then use split method with loophole in <code>.split()</code> method.
See this example:
<pre class="lang-java prettyprint-override"><code>public class SplitExample {


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

I have a multiline string which is delimited by a set of different delimiters:

<pre><code>(Text1)(DelimiterA)(Text2)(DelimiterC)(Text3)(DelimiterB)(Text4)
</code></pre>

I can split this string into its parts, using <code>String.split</code>, but it seems that I can't get the actual string, which matched the delimiter regex.

In other words, this is what I get:

<ul>
<li><code>Text1</code></li>
<li><code>Text2</code></li>
<li><code>Text3</code></li>
<li><code>Text4</code></li>
</ul>

This is what I want

<ul>
<li><code>Text1</code></li>
<li><code>DelimiterA</code></li>
<li><code>Text2</code></li>
<li><code>DelimiterC</code></li>
<li><code>Text3</code></li>
<li><code>DelimiterB</code></li>
<li><code>Text4</code></li>
</ul>

Is there any JDK way to split the string using a delimiter regex but also keep the delimiters?

How to split a string, but also keep the delimiters?

Java

Perl

 我有一个多行字符串，它由一组不同的分隔符分隔： (Text1)(DelimiterA)(Text2)(DelimiterC)(Text3)(DelimiterB)(Text4) 我可以将这个字符串分成几个部分，使用String.split，但似乎无法获得与分隔符regex匹配的实际字符串。 换句话说，这就是我所得到的...

问如何在拆分字符串的同时保留分隔符？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在拆分字符串的同时保留分隔符？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在拆分字符串的同时保留分隔符？
EN