split
public String[] split(CharSequence input,
int limit)Splits the given input sequence around matches of this pattern.
The array returned by this method contains each substring of the input sequence that is terminated by another subsequence that matches this pattern or is terminated by the end of the input sequence. The substrings in the array are in the order in which they occur in the input. If this pattern does not match any subsequence of the input then the resulting array has just one element, namely the input sequence in string form.
When there is a positive-width match at the beginning of the input sequence then an empty leading substring is included at the beginning of the resulting array. A zero-width match at the beginning however never produces such empty leading substring.
The limit parameter controls the number of times the pattern is applied and therefore affects the length of the resulting array. If the limit n is greater than zero then the pattern will be applied at most n - 1 times, the array's length will be no greater than n, and the array's last entry will contain all input beyond the last matched delimiter. If n is non-positive then the pattern will be applied as many times as possible and the array can have any length. If n is zero then the pattern will be applied as many times as possible, the array can have any length, and trailing empty strings will be discarded.
The input "boo:and:foo", for example, yields the following results with these parameters:
Regex Limit Result : 2 { "boo", "and:foo" } : 5 { "boo", "and", "foo" } : -2 { "boo", "and", "foo" } o 5 { "b", "", ":and:f", "", "" } o -2 { "b", "", ":and:f", "", "" } o 0 { "b", "", ":and:f" }
Parameters:
input - The character sequence to be split
limit - The result threshold, as described above
Returns:
The array of strings computed by splitting the input around matches of this pattern
// strings/SplitDemo.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.
import java.util.*;
import java.util.regex.*;
public class SplitDemo {
public static void main(String[] args) {
String input = "This!!unusual use!!of exclamation!!points";
System.out.println(Arrays.toString(Pattern.compile("!!").split(input)));
// Only do the first three:
System.out.println(Arrays.toString(Pattern.compile("!!").split(input, 3)));
}
}
/* Output:
[This, unusual use, of exclamation, points]
[This, unusual use, of exclamation!!points]
*/
appendReplacement
public Matcher appendReplacement(StringBuffer sb,
String replacement)Implements a non-terminal append-and-replace step.
This method performs the following actions:
-
It reads characters from the input sequence, starting at the append position, and appends them to the given string buffer. It stops after reading the last character preceding the previous match, that is, the character at index
start()- 1. -
It appends the given replacement string to the string buffer.
-
It sets the append position of this matcher to the index of the last character matched, plus one, that is, to
end().
The replacement string may contain references to subsequences captured during the previous match: Each occurrence of ${name} or $g will be replaced by the result of evaluating the corresponding group(name) or group(g) respectively. For $g, the first number after the $ is always treated as part of the group reference. Subsequent numbers are incorporated into g if they would form a legal group reference. Only the numerals '0' through '9' are considered as potential components of the group reference. If the second group matched the string "foo", for example, then passing the replacement string "$2bar" would cause "foobar" to be appended to the string buffer. A dollar sign ($) may be included as a literal in the replacement string by preceding it with a backslash (\$).
Note that backslashes (\) and dollar signs ($) in the replacement string may cause the results to be different than if it were being treated as a literal replacement string. Dollar signs may be treated as references to captured subsequences as described above, and backslashes are used to escape literal characters in the replacement string.
This method is intended to be used in a loop together with the appendTail and find methods. The following code, for example, writes one dog two dogs in the yard to the standard-output stream:
Pattern p = Pattern.compile("cat"); Matcher m = p.matcher("one cat two cats in the yard"); StringBuffer sb = new StringBuffer(); while (m.find()) { m.appendReplacement(sb, "dog"); } m.appendTail(sb); System.out.println(sb.toString());
Parameters:
sb - The target string buffer
replacement - The replacement string
Returns:
This matcher
Throws:
IllegalStateException - If no match has yet been attempted, or if the previous match operation failed
IllegalArgumentException - If the replacement string refers to a named-capturing group that does not exist in the pattern
IndexOutOfBoundsException - If the replacement string refers to a capturing group that does not exist in the pattern
// strings/TheReplacements.java
// (c)2017 MindView LLC: see Copyright.txt
// We make no guarantees that this code is fit for any purpose.
// Visit http://OnJava8.com for more book information.
import java.nio.file.*;
import java.util.regex.*;
import java.util.stream.*;
/*! Here's a block of text to use as input to
the regular expression matcher. Note that we
first extract the block of text by looking for
the special delimiters, then process the
extracted block. !*/
public class TheReplacements {
public static void main(String[] args) throws Exception {
String s = Files.lines(Paths.get("TheReplacements.java")).collect(Collectors.joining("\n"));
// Match specially commented block of text above:
Matcher mInput = Pattern.compile("/\\*!(.*)!\\*/", Pattern.DOTALL).matcher(s);
if (mInput.find()) {
s = mInput.group(1); // Captured by parentheses
}
// Replace two or more spaces with a single space:
s = s.replaceAll(" {2,}", " ");
// Replace 1+ spaces at the beginning of each
// line with no spaces. Must enable MULTILINE mode:
s = s.replaceAll("(?m)^ +", "");
System.out.println(s);
s = s.replaceFirst("[aeiou]", "(VOWEL1)");
StringBuffer sbuf = new StringBuffer();
Pattern p = Pattern.compile("[aeiou]");
Matcher m = p.matcher(s);
// Process the find information as you
// perform the replacements:
while (m.find()) {
m.appendReplacement(sbuf, m.group().toUpperCase());
}
System.out.println("appendReplacement sbuf:" + sbuf);
// Put in the remainder of the text:
m.appendTail(sbuf);
System.out.println(sbuf);
}
}
/* My Output:
Here's a block of text to use as input to
the regular expression matcher. Note that we
first extract the block of text by looking for
the special delimiters, then process the
extracted block.
appendReplacement sbuf:H(VOWEL1)rE's A blOck Of tExt tO UsE As InpUt tO
thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE
fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr
thE spEcIAl dElImItErs, thEn prOcEss thE
ExtrActEd blO
H(VOWEL1)rE's A blOck Of tExt tO UsE As InpUt tO
thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE
fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr
thE spEcIAl dElImItErs, thEn prOcEss thE
ExtrActEd blOck.
*/
The replacement String s in replaceFirst() and replaceAll() are just literals, so when performing some processing on each replacement, they don’t help. In that case, use appendReplacement() to write any amount of code in the process of performing the replacement.
references:
1. On Java 8 - Bruce Eckel
3. https://github.com/wangbingfeng/OnJava8-Examples/blob/master/strings/SplitDemo.java
5. https://github.com/wangbingfeng/OnJava8-Examples/blob/master/strings/TheReplacements.java
6. https://stackoverflow.com/questions/10915924/replacing-a-string-using-replaceall-or-pattern-matcher