枚舉，正則表達式，Base64加密和解密

一.枚舉

  枚舉:
    1.概述:引用數據類型
          類  數組  接口  註解  [枚舉]
    2.關鍵字:enum->java.lang.Enum類，是所有枚舉的父類。
    3.枚舉：裏面一般都定義常量(默認的修飾符 public static final但是定義的時候寫上報錯)
    4.特點:定義的常量都是這個枚舉類的對象
           一個沒枚舉類中有多個對象(多例)
    5.問題:我們定義出來的常量,數據類型應該是什麼:本類類型
    6.使用場景:一般用在表示狀態上(如果用1234表示狀態不太好,用枚舉是最好的)
        提交訂單: 未付款
        提交訂單: 已付款
        提交訂單: 未發貨
        提交訂單: 已發貨(發貨中)
        提交訂單: 派件中
        提交訂單: 已簽收

     7.枚舉中定義構造:(瞭解)
          a.無參構造:默認權限修飾符是private
          b.有參構造:private,要是賦值的話,我們可以利用常量直接賦值 :RED("紅色")

//枚舉的定義
public enum Color{
    RED,GREEN,YELLOW;//分號可寫,可不寫,但是建議寫上,因爲我們要後面寫其他的代碼
}

public enum Color {
    //由於三個常量都是本類對象,直接往括號中寫值,就相當於利用有參構造賦值
    RED("紅色"),GREEN("綠色"),YELLOW;
    //定義一個空參構造
    private Color(){

    }

    private String color;
    private Color(String color){
        this.color = color;
    }

    public String getColor() {
        return color;
    }
}

public class Test {
    public static void main(String[] args) {
        /*Color red = Color.RED;
        System.out.println(red.toString());*/
        System.out.println("-----------------------");
        Color red = Color.RED;
        System.out.println(red.getColor());

    }
}

二.正則表達式

1.正則表達式的概念及演示

package com.itheima.demo04Regex;

import java.util.Scanner;

/*
    正則表達式:
        就是一個包含某些規則的字符串
        用來對其他的字符串進行校驗,校驗其他的字符串是否滿足正則表達式的規則
    需求:
        對QQ號進行校驗
        1.長度5-15位
        2.全是數字
        3.第一位不能是0
   校驗QQ號的正則表達式
        "[1-9][0-9]{4,14}"

 */
public class Demo01Regex {
    public static void main(String[] args) {
        //獲取一個用戶輸入的QQ號
        System.out.println("請輸入一個QQ號:");
        String qq = new Scanner(System.in).nextLine();
        boolean b1 = checkQQ(qq);
        System.out.println("b1:"+b1);
        boolean b2 = checkQQRegex(qq);
        System.out.println("b2:"+b2);
    }

    //定義校驗QQ號的方法,不使用正則表達式
    public static boolean checkQQ(String qq){
        //1.長度5-15位
        if(qq.length()<5 || qq.length()>15){
            return false;
        }
        //2.全是數字
        char[] chars = qq.toCharArray();
        for (char c : chars) {
            //判斷字符是否在'0'到'9'之間
            if(c<'0' || c>'9'){
                return false;
            }
        }

        //3.第一位不能是0
        if("0".equals(qq.charAt(0)+"")){
            return false;
        }

        //滿足所有的規則
        return true;
    }

    /*
        定義校驗QQ號的方法,使用正則表達式
        String類中的方法:
            boolean matches(String regex) 告知此字符串是否匹配給定的正則表達式。
                判斷字符串是否滿足正則表達式的規則
                    滿足:返回true
                    不滿足:返回false
     */
    public static boolean checkQQRegex(String qq){
        return qq.matches("[1-9][0-9]{4,14}");
    }
}

2.正則表達式-字符類

package com.itheima.demo04Regex;

/*
    java.util.regex.Pattern:正則表達式的編譯表示形式。
    正則表達式-字符類:[]表示一個區間,範圍可以自己定義
        語法示例：
        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之間的任意一個字符
 */
public class Demo02Regex {
    public static void main(String[] args) {
        String str = "ead";//false
        //1.驗證str是否以h開頭，以d結尾，中間是a,e,i,o,u中某個字符
        String regex = "h[aeiou]d";
        str = "hid";//true
        str = "Hud";//false
        boolean b1 = str.matches(regex);
        System.out.println("b1:"+b1);

        //2.驗證str是否以h開頭，以d結尾，中間不是a,e,i,o,u中的某個字符
        regex = "h[^aeiou]d";
        str = "h1d";//true
        str = "had";//false
        boolean b2 = str.matches(regex);
        System.out.println("b2:"+b2);

        //3.驗證str是否a-z的任何一個小寫字符開頭，後跟ad
        regex = "[a-z]ad";
        str = "wad";//true
        str = "1ad";//false
        boolean b3 = str.matches(regex);
        System.out.println("b3:"+b3);

        //4.驗證str是否以a-d或者m-p之間某個字符開頭，後跟ad
        regex = "[a-dm-p]ad";
        str = "cad";//true
        str = "ead";//false

        boolean b4 = str.matches(regex);
        System.out.println("b4:"+b4);
    }
}

3.正則表達式-邏輯運算符

package com.itheima.demo04Regex;

/*
    正則表達式-邏輯運算符
        語法示例：
        1. &&：並且
        2. | ：或者
 */
public class Demo03Regex {
    public static void main(String[] args) {
        String str = "had";//true
        str = "ead";//false
        str = "Had";//false

        //1.要求字符串是小寫[a-z]和字符[^aeiou]開頭，後跟ad
        String regex = "[[a-z]&&[^aeiou]]ad";
        boolean b1 = str.matches(regex);
        System.out.println("b1:"+b1);

        //2.要求字符串是aeiou中的某個字符開頭，後跟ad
        regex = "[a||e||i||o||u]ad";//"[a|e|i|o|u]ad"就相當於"[aeiou]" 或運算符是可以省略不寫的
        str = "aad";//true
        str = "1ad";//false
        boolean b2 = str.matches(regex);
        System.out.println("b2:"+ b2);
    }
}

4.正則表達式-預定義字符

package com.itheima.demo04Regex;

/*
    正則表達式-預定義字符
    語法示例：
    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 Demo04Regex {
    public static void main(String[] args) {
        //1.驗證str是否3位數字
        String str = "250";//true
        str = "25a";//false
        String regex = "[0-9][0-9][0-9]";
        regex = "\\d\\d\\d";
        boolean b1 = str.matches(regex);
        System.out.println("b1:"+b1);

        //2.驗證手機號：1開頭，第二位：3/5/8，剩下9位都是0-9的數字
        regex = "1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d";
        str = "13800138000";//true
        str = "23800138000";//false
        str = "138001380001";//false
        str = "13800138a00";//false
        boolean b2 = str.matches(regex);
        System.out.println("b2:"+b2);

        //3.驗證字符串是否以h開頭，以d結尾，中間是任何字符
        regex = "h.d";
        str = "h&d";//true
        str = "h中d";//true
        str = "1Ad";//false
        boolean b3 = str.matches(regex);
        System.out.println("b3:"+b3);

        //4.驗證str是否是:had.
        //注意: .不是任意字符,就是一個普通的.需要使用轉義字符把有特殊含義的.轉換爲普通的.
        //注意:當.作爲正則表達式規則的時候才需要轉移,如果單純的當做字符串操作,就是普通的字符.
        regex = "had\\.";
        str = "hadA";//false
        str = "had.";//true
        boolean b4 = str.matches(regex);
        System.out.println("b4:"+b4);
    }
}

5. 正則表達式-數量詞

package com.itheima.demo04Regex;

/*
    正則表達式-數量詞
        語法示例：
        1. X? : x出現的數量爲 0次或1次
        2. X* : x出現的數量爲 0次到多次 任意次
        3. X+ : x出現的數量爲 1次或多次 X>=1次
        4. X{n} : x出現的數量爲 恰好n次 X=n次
        5. X{n,} : x出現的數量爲 至少n次 X>=n次
        6. X{n,m}: x出現的數量爲 n到m次(n和m都是包含的)   n=<X<=m
 */
public class Demo05Regex {
    public static void main(String[] args) {
        String str = "";//false
        str = "123";//true
        str = "1234";//false

        //1.驗證str是否是三位數字
        String regex = "\\d{3}";
        boolean b1 = str.matches(regex);
        System.out.println("b1:"+b1);

        //2.驗證str是否是多位數字:1次以上的數字
        regex = "\\d+";
        str = "12312413221312";//true
        str = "1";//true
        str = "";//false
        str = "111a";//false
        boolean b2 = str.matches(regex);
        System.out.println("b2:"+b2);

        //3.驗證str是否是手機號:1開頭，第二位：3/5/8，剩下9位都是0-9的數字
        regex = "1[358]\\d{9}";
        str = "13800138000";//true
        str = "1380013800a0";//false
        boolean b3 = str.matches(regex);
        System.out.println("b3:"+b3);

        //4.驗證小數:必須出現小數點，但是隻能出現1次
        System.out.println(d);
        regex = "\\d*\\.\\d+";
        str = "1.1";//true
        str = ".1";//true
        str = "1.";//true
        str = "aa.1";
        str = "1.1.1";

        boolean b4 = str.matches(regex);
        System.out.println("b4:"+b4);

        //5.驗證小數：小數點可以不出現，也可以出現1次
        regex = "\\d*\\.?\\d*";
        str = "10000";//true
        str = "10000.13213123";//true
        str = ".1212312";//true
        str = "";//true
        str = "a";//false
        str = "a";//false
        str = "11..11";//false
        boolean b5 = str.matches(regex);
        System.out.println("b5:"+b5);
        
        //6.驗證qq號碼：1).5--15位；2).全部是數字;3).第一位不是0
        regex = "[1-9]\\d{4,14}";
        str = "11111";//true
        str = "111";//false
        str = "111111a";//false
        boolean b7 = str.matches(regex);
        System.out.println("b7:"+b7);
    }
}

6.正則表達式-分組括號( )

package com.itheima.demo04Regex;

/*
    正則表達式-分組括號( )
 */
public class Demo06Regex {
    public static void main(String[] args) {
       
        //校驗字符串"abc"可以出現任意次
        String regex = "(abc)*";
        boolean b1 = str.matches(regex);
        
        String str = "abc";//true
        str = "";//true
        str = "abcabc";//true
        str = "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc";//true
        str = "abcaaabbbccc";//false
        
        System.out.println("b1:"+b1);

        str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";//b2:true
        str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G-";//b2:false
        //驗證這個序列號：分爲5組，每組之間使用-隔開，每組由5位A-Z或者0-9的字符組成
        regex = "([A-Z0-9]{5}-){4}[A-Z0-9]{5}";
        boolean b2 = str.matches(regex);
        System.out.println("b2:"+b2);
    }
}

7.String類中和正則表達式相關的方法

package com.itheima.demo04Regex;

/*
    String類中和正則表達式相關的方法
        boolean matches(String regex) 判斷字符串是否匹配給定的正則表達式。
        String[] split(String regex) 根據給定正則表達式的匹配拆分此字符串。
        String replaceAll(String regex, String replacement)把滿足正則表達式的字符串,替換爲新的字符串
 */
public class Demo07Regex {
    public static void main(String[] args) {
        show04();
    }

    /*
        String[] split(String regex) 根據給定正則表達式的匹配拆分此字符串。
     */
    private static void show01() {
        String s = "11-22-33-44-55";
        String[] arr = s.split("-");
        for (String str : arr) {
            System.out.println(str);
        }
    }

    //正則表達式中.代表任意字符串
    private static void show02() {
        String s = "192.168.1.100";
        String[] arr = s.split("\\.");
        System.out.println(arr.length);
        for (String str : arr) {
            System.out.println(str);
        }
    }

    private static void show03() {
        String s = "192 168 1 100";
        s = "192       168       1         100";
        String[] arr = s.split(" +");//根據一個空格或者多個連續的空格切割字符串
        System.out.println(arr.length);
        for (String str : arr) {
            System.out.println(str);
        }
    }

    /*
        String replaceAll(String regex, String replacement)把滿足正則表達式的字符串,替換爲新的字符串
     */
    public static void show04(){
        String s = "12312asfdsa12123asa11c1fzvs1v*&&3242fsfa11";
        System.out.println("原字符串:"+s);
        //需求:使用replaceAll方法把字符串中每一個數字替換爲@_@
        String reg = "\\d";
        String s1 = s.replaceAll(reg, "@_@");
        System.out.println("替換後的字符串:"+s1);
        //需求:使用replaceAll方法把字符串中的連續的數字替換爲@_@
        reg = "\\d+";
        String s2 = s.replaceAll(reg,"@_@");
        System.out.println("替換後的字符串:"+s2);
    }
}

8.正則表達式生成網址:

https://www.sojson.com/regex/generate

三.Base64加密和解密(JDK8的新特性)

java.util.Base64
        該類僅由用於獲得Base64編碼方案的編碼器和解碼器的靜態方法組成。
    作用:
        使用Base64裏邊的編碼器對數據進行編碼(加密)
        使用Base64裏邊的解碼器對數據進行解碼(解密)
    靜態成員方法:
        static Base64.Encoder getEncoder​() 獲取加密器
        static Base64.Decoder getDecoder​() 獲取解密器
    java.util.Base64.Encoder:是Base64的內部類,用於對數據進行加密
        成員方法:(編碼)
            String encodeToString​(byte[] src) 使用Base64編碼方案將指定的字節數組編碼爲字符串。
    java.util.Base64.Decoder:是Base64的內部類,用於對數據進行解密
        成員方法:(解碼)
            byte[] decode​(String src) 使用Base64編碼方案將Base64編碼的字符串解碼爲新分配的字節數組。

public class Demo01Base64 {
    public static void main(String[] args) {
        String s1 = "國家的絕密文件!";
        System.out.println("原字符串:"+s1);//原字符串:國家的絕密文件!

        //使用加密器Encoder中的方法encodeToString​把字符串進行加密
        String s2 = Base64.getEncoder().encodeToString(s1.getBytes());
        System.out.println("加密後的字符串:"+s2);//加密後的字符串:5Zu95a6255qE57ud5a+G5paH5Lu2IQ==

        //使用解密器Decoder中的方法decode把加密後的字符串進行解密
        byte[] bytes = Base64.getDecoder().decode(s2);
        String s3 = new String(bytes);
        System.out.println("解密後的字符串:"+s3);
    }
}