Object-Oriented Software Engineering CS288

Transcription

1 Object-Oriented Software Engineering CS288 1

2 Regular Expressions Contents Material for this lecture is based on the Java tutorial from Sun Microsystems: The Pattern and Matcher classes Building a RegExp Java test application String Character Classes Metacharacters Simple metacharacters classes Combining patterns of metacharacters Predefined regular expressions 2

3 Regular expressions Regular expressions describe patterns in strings Within strings of text can: search edit manipulate Have a specific syntax to create regular expressions Java syntax for regular expressions is loosely based on the Perl programming language Immensely powerful tool for file parsing Java contains package java.util.regex, includes three classes: Pattern, Matcher, and PatternSyntaxException. 3

4 Pattern, Matcher, and PatternSyntaxException Pattern object represents regular expression. Pattern class has no constructors. Must use Pattern compile methods to create object. Matcher object interprets pattern and Matcher object performs match operations against an input string. PatternSyntaxException is unchecked exception when there is a syntax error in a regular expression pattern 4

5 A GUI to test regular expression matching To try out various examples of regular expressions we first build a GUI with very basic functionality Source code for the GUI is on the course web site As previously with NetBeans we first add some text fields, labels and a button JTextFields JButton JLabels 5

6 A GUI to test regular expression matching For this GUI we will output results onto main JFrame within a JTextArea Since we may have large amounts of data we want to include the JTextArea within a scroll panel. First drag this to design panel 6

7 A GUI to test regular expression matching Check that the jscrollpane is streched close enough to the bottom of the JFrame so that in the properties panel both horizontal and vertical resizable items are ticked 7

8 A GUI to test regular expression matching Add an action event handler to the jbutton 8

9 A GUI to test regular expression matching then drag JTextArea on top of scroll pane 9

10 A GUI to test regular expression matching Then add this code to the jbutton1actionperformed method Pattern pattern = Pattern.compile(jTextField1.getText()); Matcher matcher = pattern.matcher(jtextfield2.gettext()); boolean found = false; jtextarea1.append("\nsearch complete \n"); while (matcher.find()) { jtextarea1.append("found text: \t" + matcher.group() + "\n" +" starting at index: \t" + matcher.start() + "\n" + " and ending at index: \t" + matcher.end() + "\n"); found = true; } 10

11 A GUI to test regular expression matching Running application provides interface something like this 11

12 String Literals cell 0 cell 1 cell 2 f o o A string literal regular expression is a search pattern that is literally the string that is used to define the pattern. A string foo will be internally compiled by the pattern object into an array of characters with initial index 0. By convention the string ends at index 3, even though the indices of the cells only go from 0 to 2. 12

13 String Literals Here we see the output from the Test GUI showing the indices for foo matched against foo 13

14 Metacharacters java.util.regex also allows searching using regular expressions that include Metacharacters Metacharacters are: ( [ { \ ^ - $ ] } )? * +. Note the '.' is another meta-character. Each of these characters defines a pattern that is used when searching or modifying a string 14

15 Metacharacters, Simple Classes Confusingly regular expressions use the word `class' to refer to a set of characters within square brackets. [ and ] are used to deliniate a regular expression that defines a set of characters [bcr]at matches "bat", "cat", or "rat" it defines a character class (accepting either "b", "c", or "r") as its first character. 15

16 Metacharacters ( [ { \ ^ - $ ] } )? * +. Problem how do we search for a metacharacter in a string? enclose it within \Q (start string quote) and \E (end string quote). Here we search for [ in the string foo[[ 16

17 Metacharacters gives a complete list of how metacharacters are used for searching. Here are some examples [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) 17

18 Metacharacters, negation Adding the ^ character at the start of a regular expression class negates the class. That is it matches strings that are not in the class of characters you get if you remove the ^ Try searching for [^bcr]at in the string bat cat sat mat fat 18

19 Metacharacters, negation [^bcr]at symbols within the square brackets define a class of characters to match against the characters outside square brackets define a literal strings to match against represents all strings containing three characters the last two must be at and the first can be any character except b,c and r. WARNING, ^ is also used to denote start of line when used in other contexts for regular expressions!!! 19

20 Metacharacters, Ranges [a-c], matches any single character in lexicographical order between a and c (inclusive) For example searching for g[a-c]g as shown below: 20

21 Metacharacters, Ranges Combining negation with ranges results in some unexpected results: Try searching for g[^a-c]g in the string gagggg gbgggg ggegg What are the results? 21

22 Metacharacters, Ranges Found text: ggg starting at index: 2 and ending at index: 5 Found text: g g starting at index: 5 and ending at index: 8 Found text: ggg starting at index: 9 and ending at index: 12 Found text: g g starting at index: 12 and ending at index: 15 Found text: geg starting at index: 15 and ending at index: 18 Notice that 'not in the range a-c' includes the space character ' ' 22

23 Metacharacters, Ranges Concatenating ranges defines the search to be the union of the separate ranges. [0-4[6-8]] is the same as [0-46-8] and matches any character either in 0-4 or in 6-8 Care needs to be taken with negation, [0-4[^a-c]] are characters in [0-4] or in [^a-c]. Therefore in [0-4] or NOT in [a-c] 23

24 Intersection [a-z&&[^bc]] characters that are in the [a-z] class and are in the [^bc] class Hence characters in [a-z] and not in [bc] 24

25 Predefined regular expressions. (This is a single '.' metacharacter) Any character (may or may not match line terminators) \d A digit: [0-9] \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: [a-za-z_0-9] \W A non-word character: [^\w] 25

26 Try \w in a+ 1,b 26

27 Try \W in same string 27

28 Quoting Meta-Characters In code when defining metacharacters as, for example in a field, it is necessary to use the escape character to tell Java that the string being defined is not meant to be interpreted as a metacharacter (yet) private final String REGEX = "\\d"; // a single digit 28

29 Quantifiers These allow you to specify whether there are multiple occurences of a class of characters. Such as any number of these repeated greater than 0 times. Greedy quantifiers (where X is a regular expression defining a class) X? X, once or not at all X* X, zero or more times X+ X, one or more times X{n} X{n,} X, exactly n times X, at least n times X{n,m} X, at least n but not more than m times 29

30 The? metacharacter 30

31 Note the meaning is subtlety different when we do no include the [ ] In this case it means an 'a' followed by 0 or 1 occurrences of 'b' 31

32 The * metacharacter 32

33 The * metacharacter This time surrounded by [ ] 33

34 The + metacharacter no use of [ ] 34

35 The + metacharacter This time surrounded by [ ] 35

36 Other quantifiers See for a complete list of quantifiers 36

37 Boundary matchers ^ The beginning of a line (YES this is the same character that when in [ ] means negation!) $ 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 \z The end of the input 37

38 The ^ metacharacter 38

39 Capturing Groups with ( ) Grouping characters within ( ) forces the string that they represent to be searched for, and not the class of expressions For example ^(cat)* means find a string from the start of the line that consists of the string cat repeated any number of times. Note ( ) probably wont have much effect inside [ ] 39

40 Capturing Groups with ( ) Note we do make a difference if we use the ( ) construct on the outside of a regular expression containing [ ] Notice how + is greedy, it matches largest string possible 40

41 Capturing Groups with ( ) Whereas? matches as little as possible 41

42 Capturing Groups with ( ) Groups are numbered by counting opening parentheses from left to right. In ((A)(B(C))), for example (each of A, B, C is itself some sort of regular expression), there are four capturing groups: 1. ((A)(B(C))) 2. (A) 3. (B(C)) 4. (C) Group 0 represents the entire expression, but is not a capturing group It is important to know the group numbering since the Matcher class allows to access these groups directly by their indices. 42

43 Split String Method import java.util.regex.pattern; import java.util.regex.matcher; public class SplitDemo { private static final String REGEX = ":"; private static final String INPUT = "one:two:three:four:five"; public static void main(string[ ] args) { Pattern p = Pattern.compile(REGEX); String[ ] items = p.split(input); for(string s : items) { System.out.println(s); }}} OUTPUT: one two three four five 43