Detailed explanation of the use of functions in Java

Use of Java functions

In addition to Pattern (String regex),

There is another version of the compile() method of the Pattern class:

Pattern (String regex,int flag), which accepts a flag to adjust the matching behavior.

flags come from constants in the following Pattern class:

Among these tags, Pattern.CASE_INSENSITIVE(?i) , (?m), ==(?x)==.

Examples of use are as follows:

We can combine multiple tags through the "or" ( | ) operation

import ;
import ;
public class ReFlags {
 public static void main(String[] args) {  
  Pattern p=("^java",Pattern.CASE_INSENSITIVE|);
  /*
    * Use Pattern.CASE_INSENSITIVE (case-insensitive matching) and (multi-line pattern) tags to ignore case matching of all rows starting with java
    */
  
  Matcher m=("java has regex\nJava has regex\n"
    + "JAVA has pretty good regular expression\n"
    + "Regular expressions are in JavA");
  while (()) { 
   (());//Output the matched part  }
 }
}

Output result:

java

Java

JAVA

Example of using (?x):

import ;
import ;
public class ReFlags_Comments {
 public static void main(String[] args) {
  /*
    * Not used (not started comments)
    */
         String s="123";
         Pattern p1=(" (\\d+)+#test comments");
         Matcher m1=(s);
         (());//false
         /*
                     * Use the flag to start annotation in regular expressions
           */
         Pattern p2=("(?x) (\\d+)+#test comments");
         Matcher m2=(s);
         (());//true
         /*
                * Used in the parameter to start the comment
           */
         Pattern p3=("  (\\d+)+#test comments",);
         Matcher m3=(s);
         (());//true 
 }
}

Running results:

false

true

true

Related explanation of functions

function:

Pattern (String regex, int flag)

The range of values ​​of flags is as follows:

• Pattern.CANON_EQ: A match is determined if and only if the "canonical decomposition" of the two characters is exactly the same. For example, after using this flag, the expression "a\u030A" will match "?". By default, "canonical equality" is not considered.
• Pattern.CASE_INSENSITIVE: By default, case-insensitive matching is only available for US-ASCII character sets. This flag allows expressions to ignore case for matching. To match Unicode characters with unknown size, just combine UNICODE_CASE with this flag.
• : In this mode, the space characters (in regular expressions) will be ignored when matching (not referring to "\\s" in the expression, but referring to spaces, tabs, carriage return, etc.) in the expression. Comments start at # and end at this line. Unix row mode can be enabled through embedded flags.
• : In this mode, the expression '.' can match any character, including the ending character representing a line. By default, the expression '.' does not match the ending character of the line.
• : In this mode, '^' and '$' match the beginning and end of a row respectively. Additionally, '^' still matches the beginning of the string, and '$' also matches the end of the string. By default, these two expressions only match the beginning and end of the string.
• Pattern.UNICODE_CASE: In this mode, if you also enable the CASE_INSENSITIVE flag, it will match Unicode characters with unidentified case. By default, case-insensitive matching is only available for US-ASCII character sets.
• Pattern.UNIX_LINES(?d) In this mode, only '\n' is considered an abort of a line and matches '.', '^', and '$'.

The above is personal experience. I hope you can give you a reference and I hope you can support me more.