Replace the found matching substring with the new substring

String regex = "store";
String s = "http://store.store.com";
System.out.println(s.replaceAll(regex, "www"));
System.out.println(s);
Copy the code

Run the result without changing the previous string

http://www.www.com
http://store.store.com
Copy the code

Replace and replaceAll can achieve the same effect. The difference is:

Replace: The parameters are target and replacement, which are the target object to replace and the new object

ReplaceAll: The arguments are regex and replacement. The second argument is the same. The first argument represents a regular expression, which means replaceAll supports regular expression replacement. Such as:

String str = "www.google.com";
System.out.print("Match successful return value :" );
System.out.println(str.replaceAll("(.*)google(.*)"."baidu" ));
Copy the code

Running results:

Matching success return value :baidu

ReplaceFirst: The argument is the same as replaceAll, except that it matches the first result

Pattern encapsulates regular expressions. Matcher encapsulates regular expressions and strings to match

Create instance Pattern p = pattern.compile (regular expression); Matcher m = p.m Matcher (string to match);

Find () looks back for the next matching substring. Returns a Boolean value indicating whether it was found

Find (int from) Searches backwards from the specified position

Group () extracts the substring just found

Start (), end() Specifies the start and end positions of the substring just found

Chestnut: Matches 3 to more numbers in a string

		System.out.println("Input:);
        String s = new Scanner(System.in).nextLine();

        //3 to multiple consecutive digits
        String regex = "\\d{3,}";

        Matcher m = Pattern.compile(regex)
                .matcher(s);

        // Keep looking backwards until false
        while (m.find()) {
            String s2 = m.group();
            int start = m.start();
            int end = m.end();
            System.out.println(start + "-" + end + ":" + s2);
        }
Copy the code

The output

Input: ABCD1234efg56Higk789 4-8:12317-20:789

A locator simply defines where certain characters appear.

The regular expression locator is

^ For example, the regular expression ^a uses the ^ locator, so the string must start with a. Therefore, the characters that match the preceding regular expression include ABC and absolute characters that start with a, but back and 123 characters do not match.

When ^ is followed directly by the string, it indicates the beginning of the entire string. When followed by an expression, matches the string that begins with that expression. Here’s an example.

^123[0-9]*[3] : Finds a string starting with 123 + any number of characters between 0 and 9 + 3. Can match 123999123, 1235673, etc. ^[123][0-9]*[3] : Find a string with any number of digits + 3 starting with [1 or 2 or 3] + numbers between 0 and 9. It can match 29993, 303, etc. ^(123).*[3] : Find a string starting with [123] + any number of arbitrary characters + 3. Can match 123AABBCC3, 1233, etc.

The difference between ^a and [^a] on the tip of the use of two cases :(1) locator; (2)] [^… metacharacters

Many beginners are easy to confuse the tip horn, in fact, we can understand: tip horn, only one special case, is [^…] In metacharacters like this, the uppermost character means “not”; in other cases, the uppermost character means a locator.

$

In regular expressions, the $locator is used to qualify characters at the end position. For example, the regular expression a$uses the $locator, so the string must end with a. Therefore, the strings matching the above regular expression include panda, nana and other strings ending in A, while ABC and helicopter do not match.

When the $is preceded by a character, it matches the string that ends with the entire preceding string, and when the front is an expression, it matches the string that ends with that expression. [0-9]+123: string with 1 to more characters in the front and ending with [123], such as’ 002244123 ‘. ‘[456] [123] : Matches a character string ending with [123], for example,’ 002244123 ‘. ‘^[456][123] : Matches a string ending with [123] and 1 to more digits, for example, 002244123. ‘[456][123] : Find a string that starts with [4 or 5 or 6] and ends with [1 or 2 or 3], such as 43.

\b \b contains the regular expression er\\b between words and Spaces. It matches er in order to, but not er in verb.

\b also contains the start and end positions of the target string. The regular expression \\ba[a-z]{7}\\b matches any word with a length of 8 starting with the letter “a”. Thus \b defines the beginning and end of words.

It is very common to use 2 \ bs to match a word. If you see two \b’s in the regular expression later, you should also know that they match words.

The position of the \b character is very important. If it is at the beginning of the string to match, it looks for the match at the beginning of the word. If it is at the end of the string, it looks for a match at the end of the word for example: the regular expression ter\\b matches the string ter in the word Chapter because it appears before the word boundary.

\B In regular expressions, the \B locator is used to qualify a character that is not at the beginning or end of a word. The regular expression er\\B matches er in verb but not er in order.

		String str = "2013hello04world20";
        // Replace the number with *
        System.out.println(str.replaceAll("\\d"."*"));
        // Replace consecutive numbers with *
        System.out.println(str.replaceAll("\\d+"."*"));
        // Replace the last four digits of the phone with *
        str = "15200001111";
        System.out.println(str.replaceAll("\\d{4}$"."* * * *"));
        // Replace the middle four digits of the phone with *
        System.out.println(str.replaceAll("(\\d{3})(\\d{4})(\\d{3})"."$1 * * * * $3"));
        // Add an A tag to the link address to convert it into a hyperlink
        str = "http://www.baidu.com,http://www.google.com";
        System.out.println(str.replaceAll("(http://www\\.. *? \\.com)"."<a href='$1'>$1</a>"));
Copy the code

The results

****hello**world**
*hello*world*
1520000* * * *152* * * *1111
<a href='http://www.baidu.com'>http://www.baidu.com</a>,<a href='http://www.google.com'>http://www.google.com</a>
Copy the code

Note that $1, $2, and so on correspond to a parenthesis

Requirement: Format amount. Since the background amount format can change, the background returns the amount format. The APP side should replace “{0}” in the formatted string returned by the server as the amount. For example, if the background returns ￥{0}, our amount format is ￥123. The background returns ${0}, and our amount is in the format $123

		String unformattedMoney = "12.00";
        String s = "${0}";
        String regex = "\ \ {0 \ \}";
        s = s.replaceAll(regex, unformattedMoney);
        System.out.println(s);
Copy the code

The execution result

$12.00
Copy the code

Characters like {and} have special meaning in regular expressions. The first table shows [ABC]{3} with curly brackets indicating a fixed number. This expression matches: aaa/bca/ CBC /…

Here, when we need to match braces, we need to write \{. But \ is also an escape character with special meaning, so \ needs to be written as \\{. You need to escape \ first.

Special characters are characters with special meanings, for example, * in roo*t. Normally, this regular expression can match root, roooot, and roooooot. The * indicates that the character appears 0 to more times. However, if you want to find the * symbol in a string, you need to escape the *, that is, preceded by a \ ro\\**ot that matches ro****ot, root, etc.

Many metacharacters require special treatment when trying to match them. To match these special characters, the characters must first be “escaped”, that is, preceded by the backslash character \. The following table lists special characters in regular expressions