Java 基础 - 正则表达式 Regex

Text Symbol

1. The special text symbol - Meta Characters

    a. [ ] \ ^ $ . | ? * + ( )  those characters are remaining for Regex engine of some special usage.

    b. If you want to use those special text symbol as the normal text symbol, you need to added the escape/convert character '\'.

        Example ,   if you want to match the text '1+1=2', you need to use the regex "1\+1=2".

2. None display text symbol

    "\t"  represents Tab(0x09) symbol

    "\r"  represents Carriage Return(0x0D) symbol

    "\n" represents Line Break(0x0A) symbol

    That Windows adopt "\r\n" to end with one line but Linux using "\n"

Regex Charset

The regex charset is a group of chars around in regex "[]"

1. [abc] and [a-z]

    [abc] means matching with one character that is a or b or c

    [a-z] means matching with any one of the characters from a to z.

2. Negative charset '^'

    a. syntax - right after '[', follows a '^' means to fetch the other character string against with the regex charset specified.

        Example ,

        1. '[^a]+' matches on "abacad", return "bcd",  to retrieve the other character string against with 'a'.

        2. "[^abc]+" matches on "abcde", the results should be "de", against character string 'abc'

    b. First focus that, '^' can match with the '\r' or '\n'

    c. Second focus on that, '^' must to match with one charater.

        Example , "q[^u]" means it will match a sub-charset start with q and ending with a non-"u" character must, so it will not match "Iraq",  but it will match "Iraq is a country".

    d. Last focus on that,

        Only '^' is right after '[' of one charset, it means the Negative charset

        Else if it not, like this '[a^b]+', here '^' means a normal regex charset. it will match "a^b"

3. The Abbreviation

    "\d" represents with "[0-9]"

    "\w" represents represents with [a-zA-z0-9]

    "\s" represents with "Empty Char", it always includes Tab and '\r\n' or '\n'

    Revert ,

    "\D" represents with "[^\d]"

    "\W" represents with "[^\w]"

    "\S" represents with "[^\s]"

    Examples,

          a. "\s\d" matches a sub-charset heading with Empty chars right after with a Number

          b. "[\s\d]" matches one character if it was a Empty char or a Number. 

Regex Engine

1. text-directed

    Abbreviation as DFA, I do not want to deeply metioned it due to I only focus on Java Regex Engine.

2. regex-directed

    Abbreviation as NFA, most popular engine currently.

    Features

        1). Greeding quantifiers Mechanism- Always return leftmost matched one

            Example:

                a. Uses regex "regex|regex not" to match with literal "regex not"

                    it will return "regex", cause it will return the leftmost matched one not the most perfect matched one

                b. Uses regex "cat" to match with "He captured a catfish for his cat" ( Not Global Search )

                    it will return "catfish" not the "cat", cause it will return the leftmost matched one

       2). Lazy quantifiers Mechanism

        - At least to reuse the predefined one regex formula to match

       3). How to distinguish Greeding quantifiers with Lazy quantifiers mechanism

     Example belows,

        Using regex "<.+>"  to match with "This is a <EM>first</EM> test" to find out all HTML Nodes. So the expected results should be "<EM>" and </EM>.

        But we got "<EM>first</EM>" back due to Greeding matching mechansim

        1. The process of Greeding matching Mechanism

            a. Uses the first regex formula "<" matched with "<"

            b. Uses the next regex formula "<.+" to match all the remain characeter string "<EM>first</EM> test", then it failed at the End boundary. (Now, the matched stream is "<EM>first</EM> test".

            c. Uses the next "<.+>" to match with the whole stream "<EM>first</EM> test" but not matched with the regex, then do backtrace  (Backtrace - one index of the mathced stream back as the result of "<EM>first</EM> tes" , regex expression remain as it is "<.+>") --> "<EM>first</EM> tes" still not matched with the regex --> ..... --> until the "<EM>first</EM>"  matched with "<.+>".  

            d. Then return the matched result <EM>first</EM>

            Conclusion: it always to reuse the predefined one regex formula to do process match

            the same with ".+", the "?*" is also Greeding Mechansim

        2. The process of Lazy matching Mechanism

            If want to using Lazy matching, need to change the formula from "<.+>" to <.+?> , "?*" to <?*? > to enable we have use Lazy Matching

            a. Uses the start regex formula "<" matched with "<" 

            b. Uses the next regex formula "<.+" matched with "<E", now matched "<E"

            c. Uses the next regex formula "<.+>" to match next char "<EM", but failed, then backtrace

             ( Backtrace - remain the current index, regex expression backtrace one as to be "<.+ " -  compare with the Greeding Mechanism )

            d. Uses the former regex formula ".+" to match current char "M", now matched <EM

            e. Uses the next regex formula ">" matched with the next char ">"

            f.  return "<EM> "

            g. continue process a --> f, then will matched "</EM> "

            Conclusion: it alaways at least to reuse the former one regex formula to do match  

                              But the performance with Lazy Mechansim is not well

        3. The alternative to replace using Lazy Matching Mechansim

            We can use "<[^>]+>" to replace the formula "<.+>", the reason for using this is we do not need traceback

3. How to distinguish text-directed Engine and regex-directed Engine    

    Uses regex "regex|regex not" to match with literal "regex not"

    If it returned "regex", it is regex-directed Engine. If not, it is text-directed Engine 

Repeatly Matching Character

1. "?" means matches zero time or one time

2. "+" means matches one time or more time

3. "*" means matches zero time or more time

4. {min,max} means matches repeatly from min times to max times  

    {0, } == *,    {1, } == +

Mostly Common Used Regex Character "."

1. "." can matches any character, but one Exception belows can not matched,

2. Exception character - Line Break and Line seed Character

     Here is caused by the history, in the earlier time, the old computer only support line by line to read the file stream. so "." represents as the regex charset "[^\r\n]" or "^[\n]"

3. How to enable "." to match with the '\r\n' or '\n'

    - In java, the default Pattern.complie(regex)  is not support '.' to match with "[^\r\n]" or "^[\n]"

    - Then we can use Pattern.complie(regex, Pattern.DOTALL) to enable this ability.

The Anchors

1. Notion

    Anchors have some different with the regex formula, it can not matches with any character, it only represent start point and the ending point of one charset.

2. Simle Examples

    "^\d+$" -- to check the user input should be all numbers.

    "^\s*" -- to check the pre-defined blank-spaces char.

3. Multiple-Line Support/unSupport   

    Suppose we have the stream "first line \n\rsecond line "

    1) simple one line

          "^" represents the start point before "f "

         "$" represents the end point after "e "

    2) Multiple lines  

         "^" represents 2 start points , first one before "f ", 2nd one between "\n\r" and "r"

         "$" represents 2 end points , first one between "e " and "\n\r"

    3) Practice in Java

  

The Matching Mode

1. "/i" -- ignore cases

2. "/s" -- activate the single line mode

3. "/" -- activate the multiple line mode

4. how to activate the modes in the regex expression

    insert the mode expression into your regex expression, then it start to activate from where you specified.   "(?i)" -- ignore cases;  "(?-i)" -- not ignore cases

    Example

    regex "(?i)te(?-i)st " matched with "TEst" but not matched with "TEST" or "teST".

Word Boundary Charset

1. Notion

     "\b " represents the Word Boundary anchor

    Three places specified as the Word Boundaries,

       a. The beginning point of one character string

       b. The ending point of one character string

       c. The point between un-word  character and word character, the un-word character just right after the word  character or just before it

2. Example    

    "\b4\b" can matches " 4 " but can not matches " 44 ".

Selector Charset

1. Notion

    "|", Uses the selector to match one of the possiblities.

    The Selector has the lowest priority, it told regex machine that to matched the left one or right one.

2. Example

    If you want to match a character string with "cat" or "dog", you can use "cat|dog"

    If you want to match a word only with "cat" or "dot", "\b(cat|dog)\b"

3. The Greeding quantifiers and how to manipulation

    (also, "()" is specified as the group will be mentioned later)

    Suppose we have String Character "get getValue set setValue",

    a. regex "\b(set|setValue)\b" , regex machine will return "set " first cause the Greeding feature.

        The problem is that we want to find the best one "setValue "

    b. so we can easily exchange the order like this "\b(setValue|set)\b"

        But the writting style not so good

4. "()" to indentify one regex - ( "()" indicated as Group will be mentioned later )

    "()" - tell the regex machine to treat it as a individual regex expression

    so the example shows in #3 can be simply changed as "\bset(Value){1}\b"

         a. (Value) will be treated as one individual regex expression

         b. {1} indicates that must matches it one time.

         ----> So we have the best match.

  

Group and its Backward Reference

1. Group

    A charsets surrounding by "()" formula indicates this is a Group.

    - Regex Machine will caches the matched results according with the pattern expression in "()"

    - In the first one "() " we call it as first  group, so in the second one "() " we call it as 2nd    group..

    - If want to reference the results cached, using "\1 " refer to the result of 1st group, so as "\2 ".

    - Focus that, "\0 " reference itself - the entire orignial regex expression

    - "?:" indicate that not to cache the Group value for backward reference. such as "set(?:Value)"

2. Example

    Example-1:

    Assume that we have character string "<B>This is a test</B>"

    what we needed is to find out the contents of each Note

    Clues:

           1) regex pattern expression "<([A-Z]+?)>.*</\\1>"

           2) "([A-z]+?)"  as the first group   --- ( The group value is "B " after matched )

           3) "\\1"  specified as a group reference index  to reference the result of Group 1 "B "  

           4) Finally, "<([A-Z]+?)>.*</\\1>" converted as "<B>.*</B>".  

 

  Example-2  

  To remove the repeative words for the careless typing.

   Suppose that we have character string "the the world is beautiful"

   clues:

            1) Regex string "\b(\w+)\b\s+\b\1\b "

            2) then we can use some replacement strategy to replace the matched contents

 

  

 

3. Cache Strategy  

    Cache Strategy - The temporal memory of regex machine only store the latest matched one for one Group

    1) "([abc]+)=\1 " will match "cab=cab"

    2) "([abc])+=\1 " not match "cab=cab" but matched with "cab=b", cause the latest matched for Group 1 ([abc])+  is "b ".

Meta-Group and Avoding the Backtrace  

    In some special situation, the Backtrace might leads to the performance disasters of the regex mechine, furture more, it may crash the regex matchine -- So we need to avoiding backtrace by Meta-Group

   ... in progress

Looking forward/backward

Focus - Javascript only support Looking forward

1. Affirmably/Negatively forward looking

    Syntax

        Affirmably forward looking - " (?=)"

        Negatively forward looking - "(?!)"

     Example

        Negatively forward looking 

        we want to check that there is no character "u" right follows up character "q"

        So the regex expression like "q(?!=u)"

        ---- So the same with Affirmably forward looking

     Furture understood

         Forward looking will not cache the matched results for backward references, but if you want the backward references, using "(?=(regex) )"        

 2. Affirmably/Negatively backward looking

     Syntax

        Affirmably backward looking - "(?=<)"

        Negatively backward looking - "(?!<)"

        ( Additonly <> arrouding the value than forward looking )       

     Example

 3. Deeply into forward/backward looking       

 ..... in progress

 

Reference Links

CSDN: http://dragon.cnblogs.com/archive/2006/05/08/394078.html