• What is a Regular Expression?
  • A sequence of characters that defines a search pattern
• What are Regular Expressions Used For?
  • Searching (i.e., finding all sequences of characters in a source that match the pattern)
  • Validating (i.e., ensuring that a sequence of characters has certain properties)

• Regular Characters:
  • Literals
• Metacharacters:
  • Characters that describe other characters

• Some You've Seen Before:
  • \t, \n, and \r
  • \xhh (hexadecimal hh)
• Some New Ones:
  • \f (form feed)
  • \a (alert/bell)
  • \e (escape)
  • \cx (control x)

• Predefined:
  • . (any character)
  • \d (any digit), \D (any non-digit)
  • \s (any whitespace), \S (any non-whitespace)
• User Defined:
  • [abc] (a, b or c), [^abc] (any character but a, b, or c)
  • [a-zA-z] (a through z or A through Z)
  • [a-z&&[d-f]] (intersection of a through z and d through f)
  • [a-z&&[^b]] (a through z except b)

• Line Boundaries:
  • ^ (beginning of a line)
  • $ (end of a line)
• Word Boundaries:
  • \b (word boundary)
  • \B (non-word boundary)

• Quantifiers:
  • X? (X 0 or 1 times)
  • X* (X 0 or more times)
  • X+ (X 1 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 mtimes)
• Logical Operators:
  • XY (X followed by Y)
  • X|Y (X or Y)

• "Raw":
  • Use a String
• "Processed":
  • Use a Pattern (created by a call to the static Pattern.compile(String) method)

• String.split():
  • Is passed a String representation of a regular expression
• String.replaceFirst() and String.replaceAll():
  • Replace occurences of a regular expression
• String.matches():
  • Determines if a String matches a regular expression

javaexamples/basics/RegularExpressions.java (Fragment: 0)

        boolean ok;
        String  s, t, u;

        t = "David Bernstein \n CS149 \n CS159";
        s = "yes";        

        // A search (and Replace) Example:
        //   Replace any whitespace in t with a tab 
        u = t.replaceAll("\\s+", "\t");

        // A Validation Example:
        //   Check if s matches "true", "True", "yes", or "Yes"
        ok = s.matches("[tT]rue|[yY]es");
        

• Pattern.matches():
  • Searches a String for a regular expression
• Matcher :
  • Constructed using a Pattern object's matcher(String) method
  • Has a matches() that does the work

javaexamples/basics/RegularExpressions.java (Fragment: 1)

        // A valid phone number consists of an x and 4 digits or
        // 3 digits, a dash or dot, and 4 digits
        
        Matcher validator;        
        Pattern phone;
        phone = Pattern.compile("x\\d\\d\\d\\d|\\d\\d\\d[-.]\\d\\d\\d\\d");

        for (int i=0; i<args.length; i++)
        {
            validator = phone.matcher(args[i]);        
            if (validator.matches())
            {
                System.out.println(args[i]);
            }
        }