Java 的正規表示式與爬蟲

瑪拉_以琳發表於2023-03-10
Java爬蟲

正規表示式

1.1 正規表示式的概念及演示

  • 在Java中，我們經常需要驗證一些字串，例如：年齡必須是2位的數字、使用者名稱必須是8位長度而且只能包含大小寫字母、數字等。正規表示式就是用來驗證各種字串的規則。它內部描述了一些規則，我們可以驗證使用者輸入的字串是否匹配這個規則。

  • 先看一個不使用正規表示式驗證的例子：下面的程式讓使用者輸入一個QQ號碼，我們要驗證：

    • QQ號碼必須是5--15位長度
    • 而且必須全部是數字
    • 而且首位不能為0
package com.itheima.a08regexdemo;

public class RegexDemo1 {
    public static void main(String[] args) {
        /* 假如現在要求校驗一個qq號碼是否正確。
            規則:6位及20位之內，日不能在開頭，必須全部是數字。
            先使用目前所學知識完成校驗需求然後體驗一下正規表示式檢驗。
        */

        String qq ="1234567890";
        System.out.println(checkQQ(qq));

        System.out.println(qq.matches("[1-9]\\d{5,19}"));

    }

    public static boolean checkQQ(String qq) {
        //規則:6位及20位之內，日不能在開頭，必須全部是數字 。
        //核心思想:
        //先把異常資料進行過濾
        //下面的就是滿足要求的資料了。
        int len = qq.length();
        if (len < 6 || len > 20) {
            return false;
        }
        //0不能在開頭
        if (qq.startsWith("0")) {
            return false;
        }
        //必須全部是數字
        for (int i = 0; i < qq.length(); i++) {
            char c = qq.charAt(i);
            if (c < '0' | c > '9') {
                return false;
            }
        }
        return true;
    }
}
  • 使用正規表示式驗證：
public class Demo {
    public static void main(String[] args) {
        String qq ="1234567890";
        System.out.println(qq.matches("[1-9]\\d{5,19}"));
    }
}

我們接下來就重點學習怎樣寫正規表示式

1.2 正規表示式-字元類

  • 語法示例：
  1. [abc]：代表a或者b，或者c字元中的一個。
  2. [^abc]：代表除a,b,c以外的任何字元。
  3. [a-z]：代表a-z的所有小寫字元中的一個。
  4. [A-Z]：代表A-Z的所有大寫字元中的一個。
  5. [0-9]：代表0-9之間的某一個數字字元。
  6. [a-zA-Z0-9]：代表a-z或者A-Z或者0-9之間的任意一個字元。
  7. [a-dm-p]：a 到 d 或 m 到 p之間的任意一個字元。
  • 程式碼示例：
package com.itheima.a08regexdemo;

public class RegexDemo2 {
    public static void main(String[] args) {
        //public boolean matches(String regex):判斷是否與正規表示式匹配，匹配返回true
        // 只能是a b c
        System.out.println("-----------1-------------");
        System.out.println("a".matches("[abc]")); // true
        System.out.println("z".matches("[abc]")); // false

        // 不能出現a b c
        System.out.println("-----------2-------------");
        System.out.println("a".matches("[^abc]")); // false
        System.out.println("z".matches("[^abc]")); // true
        System.out.println("zz".matches("[^abc]")); //false
        System.out.println("zz".matches("[^abc][^abc]")); //true

        // a到zA到Z(包括頭尾的範圍)
        System.out.println("-----------3-------------");
        System.out.println("a".matches("[a-zA-z]")); // true
        System.out.println("z".matches("[a-zA-z]")); // true
        System.out.println("aa".matches("[a-zA-z]"));//false
        System.out.println("zz".matches("[a-zA-Z]")); //false
        System.out.println("zz".matches("[a-zA-Z][a-zA-Z]")); //true
        System.out.println("0".matches("[a-zA-Z]"));//false
        System.out.println("0".matches("[a-zA-Z0-9]"));//true


        // [a-d[m-p]] a到d，或m到p
        System.out.println("-----------4-------------");
        System.out.println("a".matches("[a-d[m-p]]"));//true
        System.out.println("d".matches("[a-d[m-p]]")); //true
        System.out.println("m".matches("[a-d[m-p]]")); //true
        System.out.println("p".matches("[a-d[m-p]]")); //true
        System.out.println("e".matches("[a-d[m-p]]")); //false
        System.out.println("0".matches("[a-d[m-p]]")); //false

        // [a-z&&[def]] a-z和def的交集。為:d，e，f
        System.out.println("----------5------------");
        System.out.println("a".matches("[a-z&[def]]")); //false
        System.out.println("d".matches("[a-z&&[def]]")); //true
        System.out.println("0".matches("[a-z&&[def]]")); //false

        // [a-z&&[^bc]] a-z和非bc的交集。(等同於[ad-z])
        System.out.println("-----------6------------_");
        System.out.println("a".matches("[a-z&&[^bc]]"));//true
        System.out.println("b".matches("[a-z&&[^bc]]")); //false
        System.out.println("0".matches("[a-z&&[^bc]]")); //false

        // [a-z&&[^m-p]] a到z和除了m到p的交集。(等同於[a-1q-z])
        System.out.println("-----------7-------------");
        System.out.println("a".matches("[a-z&&[^m-p]]")); //true
        System.out.println("m".matches("[a-z&&[^m-p]]")); //false
        System.out.println("0".matches("[a-z&&[^m-p]]")); //false

    }
}

1.3 正規表示式-邏輯運算子

  • 語法示例：

    1. &&：並且
    2. | ：或者
    3. \ ：跳脫字元
  • 程式碼示例：
public class Demo {
    public static void main(String[] args) {
        String str = "had";
        
        //1.要求字串是小寫子音字元開頭，後跟ad
        String regex = "[a-z&&[^aeiou]]ad";
        System.out.println("1." + str.matches(regex));
        
        //2.要求字串是aeiou中的某個字元開頭，後跟ad
        regex = "[a|e|i|o|u]ad";//這種寫法相當於：regex = "[aeiou]ad";
        System.out.println("2." + str.matches(regex));
    }
}

package com.itheima.a08regexdemo;

public class RegexDemo3 {
    public static void main(String[] args) {
        // \ 跳脫字元 改變後面那個字元原本的含義
        //練習:以字串的形式列印一個雙引號
        //"在Java中表示字串的開頭或者結尾

        //此時\表示跳脫字元，改變了後面那個雙引號原本的含義
        //把他變成了一個普普通通的雙引號而已。
        System.out.println("\"");

        // \表示跳脫字元
        //兩個\的理解方式：前面的\是一個跳脫字元，改變了後面\原本的含義，把他變成一個普普通通的\而已。
        System.out.println("c:Users\\moon\\IdeaProjects\\basic-code\\myapi\\src\\com\\itheima\\a08regexdemo\\RegexDemo1.java");




    }
}

1.4 正規表示式-預定義字元

  • 語法示例：

    1. "." ： 匹配任何字元。
    2. "\d"：任何數字[0-9]的簡寫；
    3. "\D"：任何非數字[^0-9]的簡寫；
    4. "\s"： 空白字元：[ \t\n\x0B\f\r] 的簡寫
    5. "\S"： 非空白字元：[^\s] 的簡寫
    6. "\w"：單詞字元：[a-zA-Z_0-9]的簡寫
    7. "\W"：非單詞字元：[^\w]
  • 程式碼示例：
public class Demo {
    public static void main(String[] args) {
        //.表示任意一個字元
        System.out.println("你".matches("..")); //false
        System.out.println("你".matches(".")); //true
        System.out.println("你a".matches(".."));//true

        // \\d 表示任意的一個數字
        // \\d只能是任意的一位數字
        // 簡單來記:兩個\表示一個\
        System.out.println("a".matches("\\d")); // false
        System.out.println("3".matches("\\d")); // true
        System.out.println("333".matches("\\d")); // false

        //\\w只能是一位單詞字元[a-zA-Z_0-9]
        System.out.println("z".matches("\\w")); // true
        System.out.println("2".matches("\\w")); // true
        System.out.println("21".matches("\\w")); // false
        System.out.println("你".matches("\\w"));//false

        // 非單詞字元
        System.out.println("你".matches("\\W")); // true
        System.out.println("---------------------------------------------");
        // 以上正則匹配只能校驗單個字元。


        // 必須是數字 字母 下劃線 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必須是數字和字元 必須是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
        
    }
}

1.5 正規表示式-數量詞

  • 語法示例：

    1. X? : 0次或1次
    2. X* : 0次到多次
    3. X+ : 1次或多次
    4. X{n} : 恰好n次
    5. X{n,} : 至少n次
    6. X{n,m}: n到m次(n和m都是包含的)
  • 程式碼示例：
public class Demo {
    public static void main(String[] args) {
         // 必須是數字 字母 下劃線 至少 6位
        System.out.println("2442fsfsf".matches("\\w{6,}"));//true
        System.out.println("244f".matches("\\w{6,}"));//false

        // 必須是數字和字元 必須是4位
        System.out.println("23dF".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("23 F".matches("[a-zA-Z0-9]{4}"));//false
        System.out.println("23dF".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("23_F".matches("[\\w&&[^_]]{4}"));//false
    }
}

1.6 正規表示式練習1

需求：

​ 請編寫正規表示式驗證使用者輸入的手機號碼是否滿足要求。

​ 請編寫正規表示式驗證使用者輸入的郵箱號是否滿足要求。

​ 請編寫正規表示式驗證使用者輸入的電話號碼是否滿足要求。

​ 驗證手機號碼 13112345678 13712345667 13945679027 139456790271

​ 驗證座機電話號碼 020-2324242 02122442 027-42424 0712-3242434

​ 驗證郵箱號碼 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn

程式碼示例：

package com.itheima.a08regexdemo;

public class RegexDemo4 {
    public static void main(String[] args) {
        /*
            需求
            請編寫正規表示式驗證使用者輸入的手機號碼是否滿足要求。請編寫正規表示式驗證使用者輸入的郵箱號是否滿足要求。請編寫正規表示式驗證使用者輸入的電話號碼是否滿足要求。
            驗證手機號碼 13112345678 13712345667 13945679027 139456790271
            驗證座機電話號碼 020-2324242 02122442 027-42424 0712-3242434
            驗證郵箱號碼 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        */

        //心得:
        //拿著一個正確的資料，從左到右依次去寫。
        //13112345678
        //分成三部分:
        //第一部分:1 表示手機號碼只能以1開頭
        //第二部分:[3-9] 表示手機號碼第二位只能是3-9之間的
        //第三部分:\\d{9} 表示任意數字可以出現9次，也只能出現9次
        String regex1 = "1[3-9]\\d{9}";
        System.out.println("13112345678".matches(regex1));//true
        System.out.println("13712345667".matches(regex1));//true
        System.out.println("13945679027".matches(regex1));//true
        System.out.println("139456790271".matches(regex1));//false
        System.out.println("-----------------------------------");

        //座機電話號碼
        //020-2324242 02122442 027-42424 0712-3242434
        //思路:
        //在書寫座機號正則的時候需要把正確的資料分為三部分
        //一:區號@\\d{2,3}
        //      0:表示區號一定是以0開頭的
        //      \\d{2,3}:表示區號從第二位開始可以是任意的數字，可以出現2到3次。
        //二:- ?表示次數，日次或一次
        //三:號碼 號碼的第一位也不能以日開頭，從第二位開始可以是任意的數字，號碼的總長度:5-10位
        String regex2 = "0\\d{2,3}-?[1-9]\\d{4,9}";
        System.out.println("020-2324242".matches(regex2));
        System.out.println("02122442".matches(regex2));
        System.out.println("027-42424".matches(regex2));
        System.out.println("0712-3242434".matches(regex2));

        //郵箱號碼
        //3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
        //思路:
        //在書寫郵箱號碼正則的時候需要把正確的資料分為三部分
        //第一部分:@的左邊 \\w+
        //      任意的字母數字下劃線，至少出現一次就可以了
        //第二部分:@ 只能出現一次
        //第三部分:
        //      3.1         .的左邊[\\w&&[^_]]{2,6}
        //                  任意的字母加數字，總共出現2-6次(此時不能出現下劃線)
        //      3.2         . \\.
        //      3.3         大寫字母，小寫字母都可以，只能出現2-3次[a-zA-Z]{2,3}
        //      我們可以把3.2和3.3看成一組，這一組可以出現1次或者兩次
        String regex3 = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";
        System.out.println("3232323@qq.com".matches(regex3));
        System.out.println("zhangsan@itcast.cnn".matches(regex3));
        System.out.println("dlei0009@163.com".matches(regex3));
        System.out.println("dlei0009@pci.com.cn".matches(regex3));


        //24小時的正規表示式
        String regex4 = "([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d";
        System.out.println("23:11:11".matches(regex4));

        String regex5 = "([01]\\d 2[0-3])(:[0-5]\\d){2}";
        System.out.println("23:11:11".matches(regex5));
    }
}

1.7 正規表示式練習2

需求

請編寫正規表示式驗證使用者名稱是否滿足要求。要求:大小寫字母，數字，下劃線一共4-16位
請編寫正規表示式驗證身份證號碼是否滿足要求。
簡單要求:
        18位，前17位任意數字，最後一位可以是數字可以是大寫或小寫的x
複雜要求:
        按照身份證號碼的格式嚴格要求。

​ 身份證號碼:
​ 41080119930228457x
​ 510801197609022309
​ 15040119810705387X
​ 130133197204039024
​ 430102197606046442

程式碼示例：

public class RegexDemo5 {
    public static void main(String[] args) {
        /*
            正規表示式練習:
            需求
            請編寫正規表示式驗證使用者名稱是否滿足要求。要求:大小寫字母，數字，下劃線一共4-16位
            請編寫正規表示式驗證身份證號碼是否滿足要求。
            簡單要求:
                18位，前17位任意數字，最後一位可以是數字可以是大寫或小寫的x
            複雜要求:
                按照身份證號碼的格式嚴格要求。

            身份證號碼:
            41080119930228457x
            510801197609022309
            15040119810705387X
            130133197204039024 I
            430102197606046442
        */

        //使用者名稱要求:大小寫字母，數字，下劃線一共4-16位
        String regex1 = "\\w{4,16}";
        System.out.println("zhangsan".matches(regex1));
        System.out.println("lisi".matches(regex1));
        System.out.println("wangwu".matches(regex1));
        System.out.println("$123".matches(regex1));


        //身份證號碼的簡單校驗:
        //18位，前17位任意數字，最後一位可以是數字可以是大寫或小寫的x
        String regex2 = "[1-9]\\d{16}(\\d|x|x)";
        String regex3 = "[1-9]\\d{16}[\\dXx]";
        String regex5 = "[1-9]\\d{16}(\\d(?i)x)";

        System.out.println("41080119930228457x".matches(regex3));
        System.out.println("510801197609022309".matches(regex3));
        System.out.println("15040119810705387X".matches(regex3));
        System.out.println("130133197204039024".matches(regex3));
        System.out.println("430102197606046442".matches(regex3));


        //忽略大小寫的書寫方式
        //在匹配的時候忽略abc的大小寫
        String regex4 = "a((?i)b)c";
        System.out.println("------------------------------");
        System.out.println("abc".matches(regex4));//true
        System.out.println("ABC".matches(regex4));//false
        System.out.println("aBc".matches(regex4));//true


        //身份證號碼的嚴格校驗
        //編寫正則的小心得:
        //第一步:按照正確的資料進行拆分
        //第二步:找每一部分的規律，並編寫正規表示式
        //第三步:把每一部分的正則拼接在一起，就是最終的結果
        //書寫的時候:從左到右去書寫。

        //410801 1993 02 28 457x
        //前面6位:省份，市區，派出所等資訊，第一位不能是0，後面5位是任意數字       [1-9]\\d{5}
        //年的前半段: 18 19 20                                                (18|19|20)
        //年的後半段: 任意數字出現兩次                                           \\d{2}
        //月份: 01~ 09 10 11 12                                               (@[1-9]|1[0-2])
        //日期: 01~09 10~19 20~29 30 31                                       (0[1-9]|[12]\\d|3[01])
        //後面四位: 任意數字出現3次 最後一位可以是數字也可以是大寫x或者小寫x        \\d{3}[\\dXx]
        String regex6 = "[1-9]\\d{5}(18|19|20)\\d{2}(@[1-9]|1[0-2])(@[1-9]|[12]\\d|3[01])\\d{3}[\\dxXx]";

        System.out.println("41080119930228457x".matches(regex6));
        System.out.println("510801197609022309".matches(regex6));
        System.out.println("15040119810705387X".matches(regex6));
        System.out.println("130133197204039024".matches(regex6));
        System.out.println("430102197606046442".matches(regex6));


    }
}

1.8 本地資料爬取

Pattern：表示正規表示式
Matcher：文字匹配器，作用按照正規表示式的規則去讀取字串，從頭開始讀取。

         在大串中去找符合匹配規則的子串。

程式碼示例：

package com.itheima.a08regexdemo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo6 {
    public static void main(String[] args) {
        /* 有如下文字，請按照要求爬取資料。
                Java自從95年問世以來，經歷了很多版本，目前企業中用的最多的是Java8和Java11，
                因為這兩個是長期支援版本，下一個長期支援版本是Java17，相信在未來不久Java17也會逐漸登上歷史舞臺
                要求:找出裡面所有的JavaXX
         */

        String str = "Java自從95年問世以來，經歷了很多版本，目前企業中用的最多的是Java8和Java11，" +
                "因為這兩個是長期支援版本，下一個長期支援版本是Java17，相信在未來不久Java17也會逐漸登上歷史舞臺";


        //1.獲取正規表示式的物件
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //2.獲取文字匹配器的物件
        //拿著m去讀取str，找符合p規則的子串
        Matcher m = p.matcher(str);

        //3.利用迴圈獲取
        while (m.find()) {
            String s = m.group();
            System.out.println(s);
        }


    }

    private static void method1(String str) {
        //Pattern:表示正規表示式
        //Matcher: 文字匹配器，作用按照正規表示式的規則去讀取字串，從頭開始讀取。
        //          在大串中去找符合匹配規則的子串。

        //獲取正規表示式的物件
        Pattern p = Pattern.compile("Java\\d{0,2}");
        //獲取文字匹配器的物件
        //m:文字匹配器的物件
        //str:大串
        //p:規則
        //m要在str中找符合p規則的小串
        Matcher m = p.matcher(str);

        //拿著文字匹配器從頭開始讀取，尋找是否有滿足規則的子串
        //如果沒有，方法返回false
        //如果有，返回true。在底層記錄子串的起始索引和結束索引+1
        // 0,4
        boolean b = m.find();

        //方法底層會根據find方法記錄的索引進行字串的擷取
        // substring(起始索引，結束索引);包頭不包尾
        // (0,4)但是不包含4索引
        // 會把擷取的小串進行返回。
        String s1 = m.group();
        System.out.println(s1);


        //第二次在呼叫find的時候，會繼續讀取後面的內容
        //讀取到第二個滿足要求的子串，方法會繼續返回true
        //並把第二個子串的起始索引和結束索引+1，進行記錄
        b = m.find();

        //第二次呼叫group方法的時候，會根據find方法記錄的索引再次擷取子串
        String s2 = m.group();
        System.out.println(s2);
    }
}

1.9 網路資料爬取（瞭解）

需求：

​ 把連線:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i中所有的身份證號碼都爬取出來。

程式碼示例：

public class RegexDemo7 {
    public static void main(String[] args) throws IOException {
        /* 擴充套件需求2:
            把連線:https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i
            中所有的身份證號碼都爬取出來。
        */

        //建立一個URL物件
        URL url = new URL("https://m.sengzan.com/jiaoyu/29104.html?ivk sa=1025883i");
        //連線上這個網址
        //細節:保證網路是暢通
        URLConnection conn = url.openConnection();//建立一個物件去讀取網路中的資料
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;
        //獲取正規表示式的物件pattern
        String regex = "[1-9]\\d{17}";
        Pattern pattern = Pattern.compile(regex);//在讀取的時候每次讀一整行
        while ((line = br.readLine()) != null) {
            //拿著文字匹配器的物件matcher按照pattern的規則去讀取當前的這一行資訊
            Matcher matcher = pattern.matcher(line);
            while (matcher.find()) {
                System.out.println(matcher.group());
            }
        }
        br.close();
    }
}

1.10 爬取資料練習

需求：

​ 把下面文字中的座機電話，郵箱，手機號，熱線都爬取出來。

來黑馬程式設計師學習Java，手機號:18512516758，18512508907或者聯絡郵箱:boniu@itcast.cn，座機電話:01036517895，010-98951256郵箱:bozai@itcast.cn，熱線電話:400-618-9090 ，400-618-4000，4006184000，4006189090手機號的正規表示式:1[3-9]\d{9}

程式碼示例：

package com.itheima.a08regexdemo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo8 {
    public static void main(String[] args) {
        /*
            需求:把下面文字中的座機電話，郵箱，手機號，熱線都爬取出來。
            來黑馬程式設計師學習Java，
            手機號:18512516758，18512508907或者聯絡郵箱:boniu@itcast.cn，
            座機電話:01036517895，010-98951256郵箱:bozai@itcast.cn，
            熱線電話:400-618-9090 ，400-618-4000，4006184000，4006189090

            手機號的正規表示式:1[3-9]\d{9}
            郵箱的正規表示式:\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}座機電話的正規表示式:θ\d{2,3}-?[1-9]\d{4,9}
            熱線電話的正規表示式:400-?[1-9]\\d{2}-?[1-9]\\d{3}

        */

        String s = "來黑馬程式設計師學習Java，" +
                "電話:18512516758，18512508907" + "或者聯絡郵箱:boniu@itcast.cn，" +
                "座機電話:01036517895，010-98951256" + "郵箱:bozai@itcast.cn，" +
                "熱線電話:400-618-9090 ，400-618-4000，4006184000，4006189090";

        System.out.println("400-618-9090");

        String regex = "(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2})" +
                "|(0\\d{2,3}-?[1-9]\\d{4,9})" +
                "(400-?[1-9]\\d{2}-?[1-9]\\d{3})";

        //1.獲取正規表示式的物件
        Pattern p = Pattern.compile(regex);

        //2.獲取文字匹配器的物件
        //利用m去讀取s，會按照p的規則找裡面的小串
        Matcher m = p.matcher(s);
        //3.利用迴圈獲取每一個資料 while(m.find()){
        String str = m.group();
        System.out.println(str);

    }
}

1.11 按要求爬取

需求：

​ 有如下文字，按要求爬取資料。

​ Java自從95年問世以來，經歷了很多版本，目前企業中用的最多的是Java8和Java11，因為這兩個是長期支援版本，下一個長期支援版本是Java17，相信在未來不久Java17也會逐漸登上歷史舞臺。

需求1：

​ 爬取版本號為8，11.17的Java文字，但是隻要Java，不顯示版本號。

需求2：

​ 爬取版本號為8，11，17的Java文字。正確爬取結果為：Java8 Java11 Java17 Java17

需求3：

​ 爬取除了版本號為8，11，17的Java文字。
程式碼示例：

public class RegexDemo9 {
    public static void main(String[] args) {
        /*
            有如下文字，按要求爬取資料。
                Java自從95年問世以來，經歷了很多版本，目前企業中用的最多的是Java8和Java11，
                因為這兩個是長期支援版本，下一個長期支援版本是Java17，相信在未來不久Java17也會逐漸登上歷史舞臺


            需求1:爬取版本號為8，11.17的Java文字，但是隻要Java，不顯示版本號。
            需求2:爬取版本號為8，11，17的Java文字。正確爬取結果為:Java8 Java11 Java17 Java17
            需求3:爬取除了版本號為8，11.17的Java文字，
        */
        String s = "Java自從95年問世以來，經歷了很多版本，目前企業中用的最多的是Java8和Java11，" +
            "因為這兩個是長期支援版本，下一個長期支援版本是Java17，相信在未來不久Java17也會逐漸登上歷史舞臺";

        //1.定義正規表示式
        //?理解為前面的資料Java
        //=表示在Java後面要跟隨的資料
        //但是在獲取的時候，只獲取前半部分
        //需求1:
        String regex1 = "((?i)Java)(?=8|11|17)";
        //需求2:
        String regex2 = "((?i)Java)(8|11|17)";
        String regex3 = "((?i)Java)(?:8|11|17)";
        //需求3:
        String regex4 = "((?i)Java)(?!8|11|17)";

        Pattern p = Pattern.compile(regex4);
        Matcher m = p.matcher(s);
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

1.12 貪婪爬取和非貪婪爬取

只寫+和表示貪婪匹配，如果在+和後面加問號表示非貪婪爬取
+? 非貪婪匹配
*? 非貪婪匹配
貪婪爬取:在爬取資料的時候儘可能的多獲取資料
非貪婪爬取:在爬取資料的時候儘可能的少獲取資料

舉例：
如果獲取資料：ab+
貪婪爬取獲取結果:abbbbbbbbbbbb
非貪婪爬取獲取結果:ab

程式碼示例：

public class RegexDemo10 {
    public static void main(String[] args) {
        /*
            只寫+和*表示貪婪匹配

            +? 非貪婪匹配
            *? 非貪婪匹配

            貪婪爬取:在爬取資料的時候儘可能的多獲取資料
            非貪婪爬取:在爬取資料的時候儘可能的少獲取資料

            ab+:
            貪婪爬取:abbbbbbbbbbbb
            非貪婪爬取:ab
        */
        String s = "Java自從95年問世以來，abbbbbbbbbbbbaaaaaaaaaaaaaaaaaa" +
                "經歷了很多版木，目前企業中用的最多的是]ava8和]ava11，因為這兩個是長期支援版木。" +
                "下一個長期支援版本是Java17，相信在未來不久Java17也會逐漸登上歷史舞臺";

        String regex = "ab+";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s);

        while (m.find()) {
            System.out.println(m.group());
        }


    }
}

1.13 String的split方法中使用正規表示式

  • String類的split()方法原型：

    public String[] split(String regex)
//引數regex表示正規表示式。可以將當前字串中匹配regex正規表示式的符號作為"分隔符"來切割字串。
  • 程式碼示例：
/*
            有一段字串:小詩詩dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
            要求1:把字串中三個姓名之間的字母替換為vs
            要求2:把字串中的三個姓名切割出來*/

String s = "小詩詩dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
//細節:
//方法在底層跟之前一樣也會建立文字解析器的物件
//然後從頭開始去讀取字串中的內容，只要有滿足的，那麼就切割。
String[] arr = s.split("[\\w&&[^_]]+");
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

1.14 String類的replaceAll方法中使用正規表示式

  • String類的replaceAll()方法原型：
public String replaceAll(String regex,String newStr)
//引數regex表示一個正規表示式。可以將當前字串中匹配regex正規表示式的字串替換為newStr。
  • 程式碼示例：
/*
            有一段字串:小詩詩dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠
            要求1:把字串中三個姓名之間的字母替換為vs
            要求2:把字串中的三個姓名切割出來*/

String s = "小詩詩dqwefqwfqwfwq12312小丹丹dqwefqwfqwfwq12312小惠惠";
//細節:
//方法在底層跟之前一樣也會建立文字解析器的物件
//然後從頭開始去讀取字串中的內容，只要有滿足的，那麼就用第一個引數去替換。
String result1 = s.replaceAll("[\\w&&[^_]]+", "vs");
System.out.println(result1);

1.15 正規表示式-分組括號( )

細節：如何識別組號？

只看左括號，不看有括號，按照左括號的順序，從左往右，依次為第一組，第二組，第三組等等

//需求1:判斷一個字串的開始字元和結束字元是否一致?只考慮一個字元
//舉例: a123a b456b 17891 &abc& a123b(false)
// \\組號:表示把第X組的內容再出來用一次
String regex1 = "(.).+\\1";
System.out.println("a123a".matches(regex1));
System.out.println("b456b".matches(regex1));
System.out.println("17891".matches(regex1));
System.out.println("&abc&".matches(regex1));
System.out.println("a123b".matches(regex1));
System.out.println("--------------------------");


//需求2:判斷一個字串的開始部分和結束部分是否一致?可以有多個字元
//舉例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)
String regex2 = "(.+).+\\1";
System.out.println("abc123abc".matches(regex2));
System.out.println("b456b".matches(regex2));
System.out.println("123789123".matches(regex2));
System.out.println("&!@abc&!@".matches(regex2));
System.out.println("abc123abd".matches(regex2));
System.out.println("---------------------");

//需求3:判斷一個字串的開始部分和結束部分是否一致?開始部分內部每個字元也需要一致
//舉例: aaa123aaa bbb456bbb 111789111 &&abc&&
//(.):把首字母看做一組
// \\2:把首字母拿出來再次使用
// *:作用於\\2,表示後面重複的內容出現日次或多次
String regex3 = "((.)\\2*).+\\1";
System.out.println("aaa123aaa".matches(regex3));
System.out.println("bbb456bbb".matches(regex3));
System.out.println("111789111".matches(regex3));
System.out.println("&&abc&&".matches(regex3));
System.out.println("aaa123aab".matches(regex3));

1.16 分組練習

需求:

​ 將字串：我要學學編編編程式設計程程程程程。

​ 替換為：我要學程式設計

String str = "我要學學編編編程式設計程程程程程";

//需求:把重複的內容 替換為 單個的
//學學                學
//編編編編            編
//程程程程程程        程
//  (.)表示把重複內容的第一個字元看做一組
//  \\1表示第一字元再次出現
//  + 至少一次
//  $1 表示把正規表示式中第一組的內容，再拿出來用
String result = str.replaceAll("(.)\\1+", "$1");
System.out.println(result);

1.17 忽略大小寫的寫法

//(?i) ：表示忽略後面資料的大小寫
//忽略abc的大小寫
String regex = "(?i)abc";
//a需要一模一樣，忽略bc的大小寫
String regex = "a(?i)bc";
//ac需要一模一樣，忽略b的大小寫
String regex = "a((?i)b)c";

1.18 非捕獲分組

非捕獲分組：分組之後不需要再用本組資料，僅僅是把資料括起來。

//身份證號碼的簡易正規表示式
//非捕獲分組:僅僅是把資料括起來
//特點:不佔用組號
//這裡\\1報錯原因:(?:)就是非捕獲分組，此時是不佔用組號的。


//(?:) (?=) (?!)都是非捕獲分組//更多的使用第一個
//String regex1 ="[1-9]\\d{16}(?:\\d|x|x)\\1";
String regex2 ="[1-9]\\d{16}(\\d Xx)\\1";
//^([01]\d|2[0-3]):[0-5]\d:[@-5]\d$

System.out.println("41080119930228457x".matches(regex2));

1.19 正規表示式練習

手機號碼:1[3-9]\\d{9}
座機號碼：0\\d{2,3}-?[1-9]\\d{4,9}
郵箱號碼：\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}
24小時：([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d
       ([01]\\d|2[0-3])(:[0-5]\\d){2}
使用者名稱:    \\w{4,16}
身份證號碼，簡單校驗：
        [1-9]\\d{16}(\\d|X|x)
        [1-9]\\d{16}[\\dXx]
        [1-9]\\d{16}(\\d(?i)X)
身份證號碼，嚴格校驗：
        [1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9|[12])\\d|3[01])\\d{3}[\\dXx]

相關文章