regexp 简单运用
//splitString s = "hello world i am 23 years";
String[] ss = s.split("\\s");
//replace
s.replaceAll("\\s", "#");
s.replaceFirst("\\d", "#");
//greedy(default) & reluctant
String greedy = "\\d*";
String lazy = "\\d*?";
//Pattern & Matcher
String phone = "my phone: 13352135478. Hers is 15984563215. call us later.";
Pattern p = Pattern.compile("\\d{11}");
Matcher m = p.matcher(phone);
while(m.find()) {
System.out.printf("find: %s, start: %d, end: %d\n", m.group(), m.start(), m.end());
}
//把整个input和regexp匹配, 类似Pattern.matches(regex, input);
boolean wholeMatch = Pattern.matches("\\d{4}-\\d{7}", "0592-6103687");
//groups
String tel = "my tel is 0592-6103625. call me at 12:00";
Pattern p2 = Pattern.compile("(\\d{4})-(\\d{7})");
Matcher m2 = p2.matcher(tel);
while(m2.find()) {
int count = m2.groupCount();
for(int i=0; i<=count; i++) {
System.out.printf("group: %s. start: %d, end: %d\n", m2.group(i), m2.start(i), m2.end(i));
}
}
//静态方法
Pattern.matches("\\d{4}", "1125f"); //false
Pattern.matches("\\d{4}", "1125"); //true
//scanner
Scanner scanner = new Scanner("xushaoxun@gmail.com mail me if you have time");
System.out.println(scanner.next("(\\w+)@(\\w+)\\.(\\w{3})"));
<!----><!----><!---->
Regular Expression
Character Classes
<a name="CHART" />CharacterClasses
a, b, or c (simple class)
[^abc]
Any character except a, b, or c(negation)
a through z, or A through Z,inclusive (range)
]
a through d, or m through p: (union)
]
d, e, or f (intersection)
]
a through z, and not m throughp: (subtraction)
Predefined Character Classes
Predefined Character Classes
.
Any character (may or may notmatch line terminators)
\d
A digit:
\D
A non-digit: [^0-9]
\s
A whitespace character: [ \t\n\x0B\f\r]
\S
A non-whitespace character: [^\s]
\w
A word character:
\W
A non-word character: [^\w]
Quantifiers
Quantifiers
Meaning
Greedy
Reluctant
Possessive
X?
X??
X?+
X, once or not at all
X*
X*?
X*+
X, zero or more times
X+
X+?
X++
X, one or more times
X{n}
X{n}?
X{n}+
X, exactly n times
X{n,}
X{n,}?
X{n,}+
X, at least n times
X{n,m}
X{n,m}?
X{n,m}+
X, at least n but not more than m times
Capturing Groups
In the expression ((A)(B(C))), for example, there are four such groups:
[*]((A)(B(C)))
[*](A)
[*](B(C))
[*](C)
There is also a special group,group 0, which always represents the entire expression.
group function
public int start(int group)
public int end(int group)
public String group(int group)
Backreferences
The section of the input stringmatching the capturing group(s) is saved in memory for later recall via backreference.A backreference is specified in the regular expression as a backslash (\) followed by a digit indicating thenumber of the group to be recalled. To match any 2 digits, followed by theexact same two digits, you would use (\d\d)\1as the regular expression
Boundary Matchers
Boundary Matchers
^
The beginning of a line
$
The end of a line
\b
A word boundary
\B
A non-word boundary
\A
The beginning of theinput
\G
The end of the previousmatch
\Z
The end of the input butfor the final terminator, if any
\z
The end of the input
Pattern class
static method
Pattern.matches(String regex, CharSequence input);
Pattern.compile(String regex, int flags);
instance method
Matcher matcher = pattern.matcher(CharSequence input);
pattern.split(CharSequence input);
java.lang.String equivalence
str.matches(regex);
String[] str.split(regex);
str.replace(regex, replacement);
Matcher class
Index Methods
Index methods provide useful index values that showprecisely where the match was found in the input string:
[*]public int start(): Returns the start index of the previous match.
[*]public int start(int group): Returns the start index of the subsequence captured by the given group during the previous match operation.
[*]public int end(): Returns the offset after the last character matched.
[*]public int end(int group): Returns the offset after the last character of the subsequence captured by the given group during the previous match operation.
Study Methods
Study methods review the input string and return aboolean indicating whether or not the pattern is found.
[*]public boolean lookingAt(): Attempts to match the input sequence, starting at the beginning of the region, against the pattern.
[*]public boolean find(): Attempts to find the next subsequence of the input sequence that matches the pattern.
[*]public boolean find(int start): Resets this matcher and then attempts to find the next subsequence of the input sequence that matches the pattern, starting at the specified index.
[*]public boolean matches(): Attempts to match the entire region against the pattern.
Replacement Methods
Replacement methods are useful methods for replacingtext in an input string.
[*]public Matcher appendReplacement(StringBuffer sb, String replacement): Implements a non-terminal append-and-replace step.
[*]public StringBuffer appendTail(StringBuffer sb): Implements a terminal append-and-replace step.
[*]public String replaceAll(String replacement): Replaces every subsequence of the input sequence that matches the pattern with the given replacement string.
[*]public String replaceFirst(String replacement): Replaces the first subsequence of the input sequence that matches the pattern with the given replacement string.
[*]public static String quoteReplacement(String s): Returns a literal replacement String for the specified String. This method produces a String that will work as a literal replacement s in the appendReplacement method of the Matcher class. The String produced will match the sequence of characters in s treated as a literal sequence. Slashes ('\') and dollar signs ('$') will be given no special meaning.
java.lang.Stringequivalence
str.replaceFirst(regex,replacement);
str.replaceAll(regex,replacement);
Some example:
[*]Use start() and end()
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(input);
while(mat.find()) {
System.out.println(mat.start());
System.out.println(mat.end());
}
[*]Use matches() and lookAt()
String input = "ofoooooooooooo";
String regex = "foo";
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(input);
System.out.println(mat.lookingAt()); //true
System.out.println(mat.matches()); //false
[*]Use appendReplacement() and appendTail()
Pattern p = Pattern.compile("cat");
Matcher m = p.matcher("a cat");
StringBuffer sb = new StringBuffer();
while (m.find()) {
m.appendReplacement(sb,"dog");
}
m.appendTail(sb);
System.out.println(sb); //just like “a cat”.replaceAll(“..”);
页:
[1]