Regular Expression in Java 101 COMP204 Source: Sun tutorial, …

What are they? a way to describe patterns in strings similar to regex in Perl cryptic syntax: “write once, ponders many times” used to search, parse, modify textual data Java: java.util.regex with Pattern, Matcher, and PatternSyntaxException class, plus utility methods in String class

String constants match regex: foo string: foo => 0:3 "foo" regex: foo string: foofoofoo => 0:3 "foo” => 3:6 "foo” => 6:9 "foo"

Meta characters Some characters are “special”, e.g. a single dot “.” matches any character: regex: cat. string: cats => 0:4 cats Others are: ([{\^-$|]})?*+. Use meta char literally: “escape” with backslash (e.g. \.), or “quote”, e.g. \Q.\E

Character classes [abc] a, b, or c (simple class) [^abc] any character except a, b, or c (negation) [a-zA-Z] a through z or A through Z, inclusive (range) [a-d[m-p]] a through d, or m through p: [a-dm-p] (union) [a-z&&[def]] d, e, or f (intersection) [a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction) [a-z&&[^m-p]] a through z, and not m through p: [a-lq- z](subtraction)

Predefined classes (see Pattern). Any character (may or may not match line terminators)line terminators \d digit: [0-9] \D non-digit: [^0-9] \s whitespace character: [ \t\n\x0B\f\r] \S non-whitespace character: [^\s] \w word character: [a-zA-Z_0-9] \W non-word character: [^\w]

Greedy Quantifiers X? X, once or not at all X* X, zero or more times X+ X, one or more times X{n} X, exactly n times X{n,} X, at least n times X{n,m} X, at least n but not more than m times

Reluctant quantifiers X?? X, once or not at all X*? X, zero or more times X+? X, one or more times X{n}? X, exactly n times X{n,}? X, at least n times X{n,m}? X, at least n but not more than m times

Possessive Qantifiers X?+ X, once or not at all X*+ X, zero or more times X++ X, one or more times X{n}+ X, exactly n times X{n,}+ X, at least n times X{n,m}+ X, at least n but not more than m times

What’s the difference // greedy quantifier regex:.*foo string: xfooxxxxxxfoo => 0:13 "xfooxxxxxxfoo" // reluctant quantifier regex:.*?foo string: xfooxxxxxxfoo => 0:4 "xfoo” => 4:13 "xxxxxxfoo" // possessive quantifier regex:.*+foo string: xfooxxxxxxfoo No match found.

Capturing groups Quantifiers apply to single characters (e.g. a*, matches everything, why?), character classes (e.g. \s+) or groups (e.g. (dog){2} ) Groups are numbered left-to-right: ((A)(B(C))) => 1 ((A)(B(C))) 2 (A) 3 (B(C)) 4 (C) refer to groups with e.g. \2 for group two: regex: (\w)\1 string: hello => 2:4 “ll”

Boundaries ^ The beginning of a line $ The end of a line \b A word boundary \B A non-word boundary \A The beginning of the input \G The end of the previous match \Z The end of the input but for the final terminator, if any terminator \z The end of the input

Pattern class boolean b = Pattern.matches("a*b", "aaaaab"); or Pattern p = Pattern.compile("a*b");compile Matcher m = p.matcher("aaaaab");matcher boolean b = m.matches();matches latter allows for efficient reuse

Splitting a string using a regex Pattern p = Pattern.compile(“a*b”); String[] items = p.split(“aabbab”); for(String s : items) System.out.println(s); similar to split(regex) method in class String String[] items = “aabbab”.split(“a*b”);

Matcher class loads of methods, e.g. to access groups (see test harness) or replace expressions: Pattern p = Pattern.compile(“dog”); Matcher m = p.matcher(“the dog runs”); String result = m.replaceAll(“cat”); System.out.println(result); => “the cat runs”

String class has one-off methods “the dog runs”.replaceFirst(“dog”,”cat”); => “the cat runs” “aabcbdabe”.split(“a*b”); => {“c”,”d”,”e”} “xfooxxxxxxfoo”.match(“.*foo”); => true