正則表達式（Java）
底層實現
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp00 {public static void main(String[] args) {String content = "1998年12月8日，第二代Java平臺的企業版J2EE發布。" +"1999年6月，Sun公司發布了第二代Java平臺（簡稱為Java2）的3個版本：" +"J2ME（Java2 Micro Edition，Java2平臺的微型版），應用于移動、無線及" +"有限資源的環境；J2SE（Java 2 Standard Edition，Java 2平臺的標" +"準版），應用于桌面環境；J2EE（Java 2Enterprise Edition，Java 2平臺" +"的企業版），應用于基于Java的應用服務器。Java 2平臺的發布，是Java發展" +"過程中最重要的一個里程碑，標志著Java的應用開始普及。";
// String regStr = "\\d\\d\\d\\d";String regStr = "(\\d\\d)(\\d\\d)";Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);/*** matcher.find() 完成的任務* 1. 根據指定的規則，定位滿足規則的子字符串(比如1998)* 2. 找到后，將子字符串的開始的索引記錄到matcher對象的屬性int[] groups;* group[0] = 0, 把該子字符串的結束的索引+1的值記錄到 groups[1] = 4;* 3. 同時記錄 oldLast 的值為 子字符串的結束的 索引+1的值即4 即下次執行find時 就從4開始匹配** matcher.find() 完成的任務* 1. 根據指定的規則，定位滿足規則的子字符串(比如(19)(98))* 2. 找到后，將子字符串的開始的索引記錄到matcher對象的屬性int[] groups;* 2.1 group[0] = 0, 把該子字符串的結束的索引+1的值記錄到 groups[1] = 4;* 2.2 記錄1組的()匹配到的字符串 groups[2] = 0 groups[3] = 2* 2.3 記錄2組的()匹配到的字符串 groups[4] = 2 groups[5] = 4* 3. 同時記錄 oldLast 的值為 子字符串的結束的 索引+1的值即4 即下次執行find時 就從4開始匹配*/while (matcher.find()) {System.out.println("找到:" + matcher.group(0));System.out.println("找到:" + matcher.group(1));//表示匹配到的子字符串的第一組子串System.out.println("找到:" + matcher.group(2));//表示匹配到的子字符串的第二組子串//分組不能越界}}
}matcher.find
public boolean find() {int nextSearchIndex = last;if (nextSearchIndex == first)nextSearchIndex++;// If next search starts before region, start it at regionif (nextSearchIndex < from)nextSearchIndex = from;// If next search starts beyond region then it failsif (nextSearchIndex > to) {for (int i = 0; i < groups.length; i++)groups[i] = -1;return false;}return search(nextSearchIndex);}
matcher.group
public String group(int group) {if (first < 0)throw new IllegalStateException("No match found");if (group < 0 || group > groupCount())throw new IndexOutOfBoundsException("No group " + group);if ((groups[group*2] == -1) || (groups[group*2+1] == -1))return null;return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();}
基礎用法
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp01 {public static void main(String[] args) {String content = "a_bchHKKay66 66sABc_jdj*@fDH \n Y298HU 寒冷 韓順平 han";
// String regStr = "[a-z]";// 查找小寫字母a-z任意一個字符
// String regStr = "[A-Z]";// 查找大寫字母A-Z任意一個字符
// String regStr = "abc";// 查找abc字符串 (默認區分大小寫)
// String regStr = "(?i)abc";// 查找abc字符串 (不區分大小寫)
// String regStr = "[0-9]";// 查找0-9任意一個字符
// String regStr = "[^0-9]";// 查找不在0-9任意一個字符
// String regStr = "[^a-z]";// 查找不在a-z任意一個字符
// String regStr = "[abcd]";// 查找abcd任意一個字符
// String regStr = "[^abcd]";// 查找不是abcd任意一個字符
// String regStr = "\\D";// 查找不是數字0-9字符
// String regStr = "\\w";// 查找字母，數字，下劃線 @不屬于范圍
// String regStr = "\\W";// 上式取反 相當于[^0-9a-zA-Z_]
// String regStr = "\\s";// 查找空白字符
// String regStr = "\\S";// 查找非空白字符
// String regStr = ".";// 查找非 \n 以外所有字符 查找.需要用 \\.String regStr = "寒|韓|han";// 選擇匹配符//Pattern.CASE_INSENSITIVE 表示匹配不區分大小寫Pattern pattern = Pattern.compile(regStr, Pattern.CASE_INSENSITIVE);// 創建對象Matcher matcher = pattern.matcher(content);while (matcher.find()) {System.out.println("找到 " + matcher.group(0));}}
}
正則限定符
| 符號 | 含義 | 示例 | 說明 | 匹配輸入 |
|---|---|---|---|---|
| * | 指定字符重復0次或n次（無要求） | (abc)* | 僅包含任意個abc字符串，相當于\w* | abc abcabcabc |
| + | 指定字符重復1次或n次（至少1次） | m+(abc)* | 以至少1個m開頭，后接任意個abc的字符串 | m mabc mabcabc |
| ? | 指定字符重復0次或1次（最多1次） | m+abc? | 以至少1個m開頭，后接ab或abc的字符串 | mab mabc mmmab mmabc |
| {n} | 只能輸入n個字符 | [abcd]{3} | 由abcd中字母組成的任意長度為3的字符串 | abc dbc adc |
| {n,} | 指定至少n個匹配 | [abcd]{3,} | 由abcd中字母組成的任意長度不小于3的字符串 | aab dbc aaabdc |
| {n,m} | 指定至少n個但不多于m個匹配 | [abcd]{3,5} | 由abcd中字母組成的任意長度不小于3，不大于5的字符串 | abc abcd aaaaa bcdab |
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp02 {public static void main(String[] args) {String content = "11111111aaaaaaahello";// String regStr = "a{3}";// 匹配 aaa
// String regStr = "1{4}";// 匹配 1111
// String regStr = "\\d{2}";// 匹配 兩位任意數字字符//Java默認匹配多的（貪婪匹配）
// String regStr = "a{3,4}";// 匹配 aaa 或 aaaa(優先)
// String regStr = "1{4,5}";// 匹配 1111 或 11111(優先)
// String regStr = "\\d{2,5}";// 匹配 2位數 或 3,4,5 實際 sout (找到 11111 (換行) 找到 111)// String regStr = "1+";// 匹配 1個1 或 多個1
// String regStr = "\\d+";// 匹配 1個數字 或 多個數字// String regStr = "1*"; // 匹配0個1或者多個1String regStr = "a1?";// 匹配 a 或 a1Pattern pattern = Pattern.compile(regStr, Pattern.CASE_INSENSITIVE);Matcher matcher = pattern.matcher(content);while (matcher.find()) {System.out.println("找到 " + matcher.group(0));}}
}正則定位符
| 符號 | 含義 | 示例 | 說明 | 匹配輸入 |
|---|---|---|---|---|
| ^ | 指定起始字符 | 1+[a-z]* | 以至少一個數字開頭，后接任意個小寫字母的字符串 | 123 6aa 555edf |
| $ | 指定結束字符 | 2\\-[a-z]+$ | 以一個數字開頭后接連字符“-”，并以至少1個小寫字母結尾的字符串 | 1-a |
| \\b | 匹配目標字符串的邊界 | han\\b | 這里說的字符串邊界指的是子串間有空格，或者是目標字符串的結束位置 | hanshunping sphan nnhan |
| \\B | 匹配目標字符串的非邊界 | han\\B | 和\b的含義相反 | hanshuping sphan nnhan |
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp03 {public static void main(String[] args) {
// String content = "123anj-556abc-945BGh";
// String content = "123-ljj";String content = "hanshunping sphan nnhan";// String regStr = "^[0-9]+[a-z]*";// 找到123anj
// String regStr = "^[0-9]+\\-[a-z]+$";// 找到123-ljj
// String regStr = "^[0-9]+\\-[a-z]+$";// 找到123-ljj// String regStr = "han\\b";// 找到 han (sphan) 找到 han (nnhan)String regStr = "han\\B";// 找到 han (hanshunping)Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);while (matcher.find()) {System.out.println("找到 " + matcher.group(0));}}
}
捕獲分組
| 常用分組構造形式 | 說明 |
|---|---|
| (pattern) | 非命名捕獲。捕獲匹配的子字符串。編號為0的第一個捕獲是由整個正則表達式模式匹配的文本，其他捕獲結果則根據左括號的順序從1開始自動編號。 |
| (?'name’pattern) | 命名捕獲。將匹配的子字符串捕獲到一個組名稱或編號名稱中。用于name的字符串不能包含任何標點符號，并且不能以數字開頭。可以使用尖括號代替單引號。 |
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp04 {public static void main(String[] args) {String content = "hanshunping s7789 nn1189han";// String regStr = "(\\d\\d)(\\d\\d)";//匹配四個數組的字符串(7789)(1189)// String regStr = "(\\d\\d)(\\d)(\\d)";/*** 找到 7789* 第一個分組 77* 第二個分組 8* 第三個分組 9* 找到 1189* 第一個分組 11* 第二個分組 8* 第三個分組 9*/String regStr = "(?<g1>\\d\\d)(?<g2>\\d\\d)";/*** 找到 7789* 第一個分組[編號] 77* 第二個分組[編號] 89* 找到 1189* 第一個分組[編號] 11* 第二個分組[編號] 89*/Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);while (matcher.find()) {System.out.println("找到 " + matcher.group(0));
// System.out.println("第一個分組 " + matcher.group(1));System.out.println("第一個分組[編號] " + matcher.group("g1"));
// System.out.println("第二個分組 " + matcher.group(2));System.out.println("第二個分組[編號] " + matcher.group("g2"));
// System.out.println("第三個分組 " + matcher.group(3));}}
}
非捕獲分組
| 常用分組構造形式 | 說明 |
|---|---|
| (?:pattern) | 匹配pattern但不捕獲該匹配的子表達式，即它是一個非捕獲匹配，不存儲供以后使用的匹配。這對于用“or”字符(|)組合模式部件的情況很有用。 |
| (?=pattern) | 它是一個非捕獲匹配。 |
| (?!pattern) | 該表達式匹配不處于匹配pattern的字符串的起始點的搜索字符串。 |
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp05 {public static void main(String[] args) {String content = "hello韓順平教育 Jack韓順平老師 韓順平同學hello";//找到 韓順平教育 、 韓順平老師 、 韓順平同學
// String regStr = "韓順平(?:教育|老師|同學)";//不能group(1)//找到 韓順平教育中的韓順平 韓順平老師中的韓順平
// String regStr = "韓順平(?=教育|老師)";//找到 不是韓順平教育中的韓順平 不是韓順平老師中的韓順平String regStr = "韓順平(?!教育|老師)";Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);while (matcher.find()) {//非捕獲分組 不能使用group(1)System.out.println("找到 " + matcher.group(0));}}
}
非貪婪匹配
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp06 {public static void main(String[] args) {String content = "hello1111111";String regStr = "\\d+?";/*** 找到 1* 找到 1* 找到 1* 找到 1* 找到 1* 找到 1* 找到 1*/Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);while (matcher.find()) {//非捕獲分組 不能使用group(1)System.out.println("找到 " + matcher.group(0));}}
}
應用實例
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp07 {public static void main(String[] args) {//漢字
// String content = "韓順平教育";
// String regStr = "^[\u0391-\uffe5]+$";//true//1-9開頭的一個六位數
// String content = "112344";
// String regStr = "^[1-9]\\d{5}$";//true//1-9開頭的一個(5-10位數)
// String content = "12389";
// String regStr = "^[1-9]\\d{4,9}$";//true//以11、13、18開頭的11位數String content = "11588889999";String regStr = "^1[1|3|8]\\d{9}$";//truePattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);if (matcher.find()) {System.out.println("true");} else {System.out.println("false");}}
}
驗證復雜URL
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp09 {public static void main(String[] args) {String content = "https://www.bilibili.com/video/BV1fh411y7R8?;/** ((http|https)://)開始部分* ([\w-]+\.)+[\w-]+ 匹配 www.bilibili.com* (\/[\w-?=&/%.#]*)? 匹配 /video/BV1fh411y7R8?p=894&vd_source=a8223634aa8a190c7233a2dc3f8a15e3* []里面的元素相當于一個集合* 如果查找 "(去掉http)edu.metastudy.vip/mt/official/pc/mxmt-ksjhdj"* regStr = "^((http|https)://)?([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";*/String regStr = "^((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);if (matcher.find()) {System.out.println("true");} else {System.out.println("false");}}
}
Pattern類matches方法
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp10 {public static void main(String[] args) {String content = "10https://www.bilibili.com/video/BV1fh411y7R8?p=894&vd_source=";String regStr = "((http|https)://)([\\w-]+\\.)+[\\w-]+(\\/[\\w-?=&/%.#]*)?$";Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);//find匹配必須加^$定位符if (matcher.find()) {System.out.println("true");} else {System.out.println("false");}//整體匹配System.out.println(Pattern.matches(regStr, content));/*** true* false*/}
}
Pattern類中的源碼：
public static boolean matches(String regex, CharSequence input) {Pattern p = Pattern.compile(regex);Matcher m = p.matcher(input);return m.matches();}
matcher方法
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp11 {public static void main(String[] args) {String content = "hello edu jack hspedutom hello smith hello";
// String regStr = "hello";String regStr = "hello edu jack tom hello smith hello";Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);while (matcher.find()) {System.out.println("================");System.out.println(matcher.start());System.out.println(matcher.end());System.out.println(content.substring(matcher.start(),matcher.end()));}System.out.println("整體匹配 " + matcher.matches());regStr = "hspedu";pattern = Pattern.compile(regStr);matcher = pattern.matcher(content);String newContent = matcher.replaceAll("韓順平教育");//并沒有改變原來的contentSystem.out.println("content = " + content);System.out.println("new = " + newContent);}
}
反向引用
- 分組 可以使用()組成一個比較復雜的匹配模式，一個圓括號的部分我們可以看作一個子表達式/一個分組
- 捕獲 把正則表達式中子表達式/分組匹配內容，保存到一個組里，方便后面引用
0代表整個表達式 - 反向引用 圓括號的內容被捕獲后，可以在這個括號后被使用，從而寫出一個比較實用的匹配模式
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp12 {public static void main(String[] args) {String content = "hello hspedu11111 hello22 12345-111222333";//找到兩個連續相同的數字
// String regStr = "(\\d)\\1";//找到五個連續相同的數字
// String regStr = "(\\d)\\1{4}";//找到個位與千位相同 十位與百位相同的數字
// String regStr = "(\\d)(\\d)\\2\\1";//找到以下格式 "五位數-九位數連續每三位相同(例如：12345-111222333)"String regStr = "\\d{5}-(\\d)\\1{2}(\\d)\\2{2}(\\d)\\3{2}";Pattern pattern = Pattern.compile(regStr);Matcher matcher = pattern.matcher(content);while (matcher.find()) {System.out.println("找到 " + matcher.group(0));}}
}
替換分割匹配
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExp13 {public static void main(String[] args) {String content = "我....我要....學學學學....編程java!";//去掉所有的 .Pattern pattern = Pattern.compile("\\.");Matcher matcher = pattern.matcher(content);content = matcher.replaceAll("");System.out.println("content=" + content);//去掉重復的字 (.)查找任意的字符 \\1反向引用出'(.)'的內容 +指重復多次 $1表示重復字符替換為1個//如果要替換ABAB型 例如"我要我要" 使用(..)\\1+content = Pattern.compile("(.)\\1+").matcher(content).replaceAll("$1");System.out.println("content=" + content);}
}
練習題
package com.hspedu.RegExp;import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegExpHomework {public static void main(String[] args) {//匹配電子郵箱 例如 shu@sohu.com shu@sougo.org.cnString content01 = "shu@sougo.org.cn";//[\\w-](@前面的英文) @([a-zA-z]+\.)(至少匹配一次@英文.)String regStr01 = "^[\\w-]+@([a-zA-z]+\\.)+[a-zA-Z]+$";if (content01.matches(regStr01)) {System.out.println("true");} else {System.out.println("false");}//匹配整數或者小數String content02 = "-0.56";//([1-9]\d*|0)判斷整數部分 不能出現0034.56String regStr02 = "^[-+]?([1-9]\\d*|0)(\\.\\d+)?$";if (content02.matches(regStr02)) {System.out.println("true");} else {System.out.println("false");}//解析urlString content03 = "http://www.sohu.com:8080/abc/index.html";String regStr03 = "^([a-zA-Z]+)://([a-zA-Z.]+):(\\d+)[\\w-/]*/([\\w.]+)$";Pattern pattern = Pattern.compile(regStr03);Matcher matcher = pattern.matcher(content03);if (matcher.matches()) {System.out.println("true");System.out.println("整體匹配=" + matcher.group(0));System.out.println("協議=" + matcher.group(1));System.out.println("域名=" + matcher.group(2));System.out.println("端口=" + matcher.group(3));System.out.println("文件=" + matcher.group(4));} else {System.out.println("false");}}
}
0-9 ??
0-9 ??
![[tsai.shen@mailfence.com].faust勒索病毒數據怎么處理|數據解密恢復](http://pic.xiahunao.cn/[tsai.shen@mailfence.com].faust勒索病毒數據怎么處理|數據解密恢復)
 GoT)
