{"id":145,"date":"2019-01-21T00:42:53","date_gmt":"2019-01-21T00:42:53","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/java\/?p=145"},"modified":"2020-08-06T09:54:32","modified_gmt":"2020-08-06T09:54:32","slug":"21-java-regular-expressions-2","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/java\/21-java-regular-expressions-2\/","title":{"rendered":"Java – Regular Expressions – 2"},"content":{"rendered":"

We have already covered the basics of regular expressions in Part 1<\/a>.\u00a0 I recommend you review it. Now we are going to examine some more useful methods. We would also write the code to demonstrate it.<\/p>\n

Furthermore, a video is provided at the end of the page<\/a>.<\/p>\n

 <\/p>\n

We would cover the following topics<\/p>\n

    \n
  1. start and end Methods<\/a><\/li>\n
  2. Matches and lookingAt Methods<\/a><\/li>\n
  3. replaceFirst and replaceAll Methods<\/a><\/li>\n
  4. appendReplacement and appendTail Methods<\/a><\/li>\n
  5. PatternSyntaxException Class Method<\/a><\/li>\n
  6. Video Explanation<\/a><\/li>\n<\/ol>\n

     <\/p>\n

     <\/p>\n

    1. start and end Methods<\/strong><\/h4>\n

    You use the start() method to find the starting index of a match in a given text. So if we have:<\/p>\n

    text = “The cup is on the floor”<\/p>\n

    And we find find that cup matches a regular expression. Then the start() method would return 4. Because that is the starting index of cup in the text. Similarly, the end() method would return 6. This is because 6 is the end index of cup in the text. That is the index of letter p.<\/p>\n

    Let’s take an example. We would write a program that counts the number of times the word cup appear in a string<\/p>\n

     <\/p>\n

    \/\/Program to count number of times<\/span>\r\n\/\/cup appears in a string<\/span>\r\nimport<\/span> java.util.regex.Matcher<\/span>;<\/span>\r\nimport<\/span> java.util.regex.Pattern<\/span>;<\/span>\r\n\r\npublic<\/span> class<\/span> RegexDemo2<\/span> {<\/span>\r\n\r\n\tpublic<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String[]<\/span> args)<\/span> {<\/span>\r\n\t\tString text =<\/span> \"This is blue cup. I need red cup\"<\/span>;<\/span>\r\n\t\tString regex =<\/span> \"\\\\bcup\\\\b\"<\/span>;<\/span>\r\n\t\t\r\n\t\tPattern pt =<\/span> Pattern.<\/span>compile<\/span>(<\/span>regex);<\/span>\r\n\t\tMatcher mt =<\/span> pt.<\/span>matcher<\/span>(<\/span>text);<\/span>\r\n\t\t\r\n\t\tint<\/span> count =<\/span> 0<\/span>;<\/span>\r\n\t\twhile<\/span>(<\/span>mt.<\/span>find<\/span>())<\/span> {<\/span>\r\n\t\t\tcount =<\/span> count +<\/span>1<\/span>;<\/span>\r\n\t\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Start index: \"<\/span> +<\/span> mt.<\/span>start<\/span>());<\/span>\r\n\t\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"End index: \"<\/span> +<\/span> mt.<\/span>end<\/span>());<\/span>\r\n\t\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"------------------------\"<\/span>);<\/span>\r\n\t\t}<\/span>\t\t\r\n\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Total count: \"<\/span> +<\/span> count);<\/span>\r\n\t}<\/span>\r\n}<\/span>\r\n<\/pre>\n
    Listing 1.0: Count how many times cup appears in a string<\/p>\n
     <\/p>\n
    I would suggest you run the code yourself. As such, you get used to it. Also try to change things a bit to see how it works. Maybe you can change cup to plate or something.<\/p>\n
    Meanwhile, the output of the program is given below.<\/p>\n
     <\/p>\n
    Start index:<\/span> 13<\/span>\r\nEnd index:<\/span> 16<\/span>\r\n------------------------<\/span>\r\nStart index:<\/span> 29<\/span>\r\nEnd index:<\/span> 32<\/span>\r\n------------------------<\/span>\r\nTotal count:<\/span> 2<\/span>\r\n<\/pre>\n
     <\/p>\n
    Also note that the program uses word boundaries \\b. This helps to ensure that the word is not inside another string. So if we have the word hiccup, then it would not match. Sure you will find it interesting to try it!<\/p>\n
     <\/p>\n
     <\/p>\n
    2. Matches and lookingAt Methods<\/strong><\/h4>\n
    The matches method as you already know matches an input text against a pattern. However, while matches tries to match the entire text, the lookingAt checks if the pattern matches the prefix of the text.<\/p>\n
    Let’s take an example.<\/p>\n
    \/\/Program to demonstrate difference<\/span>\r\n\/\/between matches() and lookingAt()<\/span>\r\nimport<\/span> java.util.regex.Matcher<\/span>;<\/span>\r\nimport<\/span> java.util.regex.Pattern<\/span>;<\/span>\r\n\r\npublic<\/span> class<\/span> RegexDemo2<\/span> {<\/span>\r\n\r\n\tpublic<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String[]<\/span> args)<\/span> {<\/span>\r\n\t\tString text =<\/span> \"big bigger bigest\"<\/span>;<\/span>\r\n\t\tString regex =<\/span> \"big\"<\/span>;<\/span>\r\n\t\t\r\n\t\tPattern pt =<\/span> Pattern.<\/span>compile<\/span>(<\/span>regex);<\/span>\r\n\t\tMatcher mt =<\/span> pt.<\/span>matcher<\/span>(<\/span>text);<\/span>\r\n\t\t\r\n\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"matches: \"<\/span> +<\/span> mt.<\/span>matches<\/span>());<\/span>\r\n\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"lookingAt: \"<\/span> +<\/span> mt.<\/span>lookingAt<\/span>());<\/span>\r\n\t}<\/span>\r\n}<\/span>\r\n<\/pre>\n
    Listing 1.1: Difference between matches() and lookingAt()<\/p>\n
     <\/p>\n
    If you run the code in Listing 1.1, you will have the result below:<\/p>\n
     <\/p>\n
    matches:<\/span> false<\/span>\r\nlookingAt:<\/span> true<\/span>\r\n<\/pre>\n
     <\/p>\n
    Notice that for matches,\u00a0 it is false. This is because, matches tries to match the entire string. For lookingAt() however, it it is true. This is because the pattern ‘big’ corresponds to the prefix of the text. That is the first part of the text is ‘big’. So it matches.<\/p>\n
     <\/p>\n
     <\/p>\n
    3. replaceFirst and replaceAll Methods<\/strong><\/h4>\n
    You use these method to replace the text that matches a given regular expression. While replaceFirst() replaces only the first match, the replaceAll replaces all matches.<\/p>\n
    Let’s take an example<\/p>\n
     <\/p>\n
    \/\/Program to demonstrate <\/span>\r\n\/\/replaceFirst() and replaceAll()<\/span>\r\nimport<\/span> java.util.regex.Matcher<\/span>;<\/span>\r\nimport<\/span> java.util.regex.Pattern<\/span>;<\/span>\r\n\r\npublic<\/span> class<\/span> RegexDemo2<\/span> {<\/span>\r\n\r\n\tpublic<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String[]<\/span> args)<\/span> {<\/span>\r\n\t\tString text =<\/span> \"big bigger bigest\"<\/span>;<\/span>\r\n\t\tString regex =<\/span> \"big\"<\/span>;<\/span>\r\n\t\t\r\n\t\tPattern pt =<\/span> Pattern.<\/span>compile<\/span>(<\/span>regex);<\/span>\r\n\t\tMatcher mt =<\/span> pt.<\/span>matcher<\/span>(<\/span>text);<\/span>\r\n\t\t\r\n\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>mt.<\/span>replaceFirst<\/span>(<\/span>\"small\"<\/span>));<\/span>\r\n\t\tSystem.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>mt.<\/span>replaceAll<\/span>(<\/span>\"small\"<\/span>));<\/span>\r\n\t}<\/span>\r\n}<\/span>\r\n<\/pre>\n
    Listing 1.2: Program to illustrate replaceFirst() and replaceAll() Methods<\/p>\n
     <\/p>\n
    If you run the code, then you will have the result below:<\/p>\n
    small bigger bigest\r\nsmall smallger smallest\r\n<\/pre>\n
     <\/p>\n
    Notice that in the first line of the output, only the first match is replaced. But in the second line, all the matches for ‘big’ is replaced with small.<\/p>\n
     <\/p>\n
     <\/p>\n
    4. appendReplacement and appendTail Methods<\/strong><\/h4>\n
    The appendReplacement()<\/strong> method does the following:<\/p>\n