枚举和正则表达式

今日目标

1. 枚举
2. JDK8的新特性（默写方法，Lambda，Stream流）
   了解即可：方法引用，Base64用于字符串编码
3. 正则表达式（理解）

1、枚举

1. 若不使用枚举会产生什么问题？？？
   拿不到想要的结果，例如：

//1.创建对象
Person p1 = new Person("张三"，"妖");
sout(p1);
Person p2 = new Person("张三"，"123");
sout(p2);
//此时，性别为String类型，赋任何值都会打印出来，但并不是我们想要的结果
//因此，应使用枚举将所有可能性一一列出，才足已解决

2. 使用及应用场景
   枚举是什么？？？—就是把所有可能的情况一一列出
   是么时间用枚举？？？—当某个数据值固定有限，可以使用枚举把其值一一列举出来

3. 枚举的基本语法
   3.1 格式
   public enum 枚举名{
   //枚举项
   枚举项1，枚举项2,…，枚举项n;
   }

   例如：
   /*
   性别的枚举
   /
   public enum sex{
   /
   Male 男性
   Female 女性
   Yao 妖
   */
   }
   3.2 入门案例

public class Person {
    private String name;
    //以前的性别sex是String类型,导致任何值都可以
    //private String sex;
    //现在我们已经有枚举类型
    private Sex sex;
    public Person() {
    }
    public Person(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Sex getSex() {
        return sex;
    }
    public void setSex(Sex sex) {
        this.sex = sex;
    }
}

public class TestPerson {
    public static void main(String[] args) {
    //1.创建对象
    //  Person p1 = new Person("张三","妖");
        Person p1 = new Person("张三",Sex.Male);
        System.out.println(p1);
        //2.再创建对象
    //  Person p2 = new Person("王五","xxx");
        Person p2 = new Person("王五",Sex.Female);
        System.out.println(p2);
    }
}        

3.3 本质
枚举的本质其实就是一个类,枚举项的本质其实当前类的一个对象

     /**
     * 性别的枚举
     */
    public enum Sex {
        Male,Female,Yao; 
    }
 
     本质===>
    public final class Sex extends java.lang.Enum<Sex>{
    public static final Sex Male = new Sex();
    public static final Sex Female = new Sex();
    public static final Sex Yao = new Sex();
    //构造方法是私有化的
    private Sex(){}    
    }
    //枚举本质是一个类,那么我们就可以在枚举中添加各种成员变量,成员方法,构造方法等!!!
    //成员变量和成员方法和普通类没有区别!!
    //构造方法: a.必须是私有的 b.使用时 枚举项(参数);

    public enum Sex {
    Male(10),Female(20),Yao(30);
    //既然枚举是一个类,那么我们就可以添加我们喜欢的成员变量和成员方法和构造方法
    private int age;
    
    public void showAge(){
    System.out.println(age);
    }
    
    private Sex(){}
    private Sex(int age){
            this.age = age;
    }
}  

3.4 应用场景

枚举表示性别：
    public enum Sex { 
     MAIL, FEMAIL; 
 }

枚举表示方向:
 public enum Orientation { 
        UP, RIGHT, DOWN, LEFT; 
    }

枚举表示季度:
 public enum Season { 
        SPRING, SUMMER, AUTUMN, WINTER; 
    }

2、JDK8的其他新特性【了解】

1. 方法引用
   1.1 介绍
   把已经存在的方法，拿过来用就可以了
   **
   **
   当我们可以为一个函数式接口类型赋值时，我们赋值该接口的实现类对象，也可以赋值该接口的匿名内部类对象，也可以赋值符合接口的Lambda表达式，也可以使用方法引用

public class Dog{	
	public void bark1() {
        	System.out.println("方法执行了...汪汪汪..");
	}
	public static void bark() {
        	System.out.println("方法执行了...汪汪汪..");
	}	   
}
public class MethodReferencesDemo {
	public static void main(String[] args) {
	//1.创建一个线程,使用实现的方法
        //a.使用接口的实现类对象,给Runnable接口类型赋值
        new Thread(new MyRunnable()).start();
        //b.使用接口的匿名内部类对象,给Runnable接口类型赋值
        new Thread(new Runnable() {
        @Override
            public void run() {
                System.out.println("线程执行了...");
            }
        }).start();
        //c.使用Lambda,直接给Runnable接口类型赋值
        new Thread(()->System.out.println("线程执行了...")).start();
        //d.把已经存在的方法直接引用过来
        //new Thread(Dog::bark).start(); //通过类名引用静态方法
        Dog dd = new Dog();
        new Thread(dd::bark1).start(); //通过对象名引用成员方法
        }
}
class MyRunnable implements Runnable{
	@Override
    	   public void run() {
           System.out.println("线程执行了...");
        }
}	

2. 方法引用基本使用格式
   通过类名引用其中的静态方法
   类名::静态方法名
   通过对象引用其中的普通方法
   对象名::普通方法名

通过类名引用其构造方法:
类名::new Person o = new Person();
通过数组引用其构造方法:
数据类型[]::new int[] arr = new int[10];
3. System.out.println这个方法引用的代码演示

public class SystemOutPrintlnDemo {
    public static void main(String[] args) {
        List names = new ArrayList();
        names.add("大明");
        names.add("二明");
        names.add("小明");
        //.StreamAPI中
        names.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        });

	names.forEach(new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        });

	names.forEach(o -> System.out.println(o));
	
	//System.out.println("hello");
        names.forEach(System.out::println);
    }
}

2. Base64
   一种常见的编码方案
   2.1 内嵌类和方法
   Decoder和Encoder
   UrlDecoder和UrlEncoder
   MimeDecoder和MimeDecoder
   **
   String encodeToString(byte[] bs); //编码
   byte[] decode(String str);//解码
   2.2 Base64代码演示

public class Base64Demo {
    public static void main(String[] args) {
        //1.Base64提供了三种编码器和解码器
        //a.基本的编码和解码
        String encodeToString = Base64.getEncoder().encodeToString("HelloWorld".getBytes());
        System.out.println(encodeToString);
        
        byte[] bytes = Base64.getDecoder().decode(encodeToString);
        System.out.println(new String(bytes));

	//b.url的编码和解码
        String encodeToString1 = Base64.getUrlEncoder().encodeToString("www.itheima.com".getBytes());
        System.out.println(encodeToString1);
        
        byte[] bs1 = Base64.getUrlDecoder().decode(encodeToString1);
        System.out.println(new String(bs1));
        
        //c.MIME类型编码器和解码器
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            UUID uuid = UUID.randomUUID();
            sb.append(uuid.toString());
        }
        String content = sb.toString();
        
	//String encodeToString2 = Base64.getMimeEncoder().encodeToString(content.getBytes());
	//System.out.println(encodeToString2);
        String encodeToString2 = Base64.getMimeEncoder(8,"-".getBytes()).encodeToString(content.getBytes());
        System.out.println(encodeToString2);
        
        byte[] bs2 = Base64.getMimeDecoder().decode(encodeToString2);
        System.out.println(new String(bs2));
    }
}

正则表达式【理解】

匹配字符串，但是里面内容表示某种规则(规则是有具体语法含义)

1. 案例正则表达式的用法

/*
案例:
 下面的程序让用户输入一个QQ号码，我们要验证：
        QQ号码必须是5--15位长度
        而且必须全部是数字
        而且首位不能为0
*/
public class TestDemo01 {
    public static void main(String[] args) {
//        案例:
//        下面的程序让用户输入一个QQ号码，我们要验证：
//        QQ号码必须是5--15位长度
//        而且必须全部是数字
//        而且首位不能为0
        //1.输入QQ
        System.out.println("请输入您的QQ号码:");
        String qq = new Scanner(System.in).next();
      //2.判断QQ是否合法
        if (qq.length() < 5 || qq.length() > 15) {
            System.out.println("您的QQ不合法..");
            return;
        }

	for (int i = 0; i < qq.length(); i++) {
            char ch = qq.charAt(i);
            if (ch < '0' || ch > '9') {
                System.out.println("您的QQ不合法..");
                return;
            }
        }

	if (qq.charAt(0) == '0') {
            System.out.println("您的QQ不合法");
            return;
        }
        System.out.println("你的QQ是合法的~~");

	//3.使用正则
        boolean b = qq.matches("[1-9]\\d{4,14}");//matches 匹配
        System.out.println(b);
    }
}

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之间的任意一个字符。
*/
//正则的字符类
public class TestDemo02 {
    public static void main(String[] args) {
        String str = "aad";
        //1.验证str是否以h开头，以d结尾，中间是a,e,i,o,u中某个字符
        System.out.println("1." + str.matches("h[aeiou]d"));
        //2.验证str是否以h开头，以d结尾，中间不是a,e,i,o,u中的某个字符
        System.out.println("2." + str.matches("h[^aeiou]d"));
        //3.验证str是否a-z的任何一个小写字符开头，后跟ad
        System.out.println("3." + str.matches("[a-z]ad"));
        //4.验证str是否以a-d或者m-p之间某个字符开头，后跟ad
        System.out.println("4." + str.matches("[a-dm-p]ad"));
    }
}

3. 正则表达式-逻辑运算符
   3.1. &&：并且
   3.2. | ：或者

/**
 * 正则表达式逻辑运算符类
 */
public class TestDemo03 {
    public static void main(String[] args) {
        String str = "bad";
        //1.要求字符串是否是除a、e、i、o、u外的其它小写字符开头，后跟ad
        System.out.println("1." + str.matches("[a-z&&[^aeiou]]ad"));
        //2.要求字符串是aeiou中的某个字符开头，后跟ad
        System.out.println("2." + str.matches("[a|e|i|o|u]ad"));
    }
}

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 TestDemo04 {
    public static void main(String[] args) {
        String str = "had.";
        //1.验证str是否3位数
        System.out.println("1." + str.matches("\\d\\d\\d"));
        //2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
        System.out.println("2." + str.matches("1[3|5|8]\\d\\d\\d\\d\\d\\d\\d\\d\\d"));
        //3.验证字符串是否以h开头，以d结尾，中间是任何字符 str = "had";//要验证的字符串
        System.out.println("3." + str.matches("h.d"));
        //4.验证str是否是：had.
        System.out.println("4." + str.matches("had\\."));
    }
}

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 TestDemo05 {
    public static void main(String[] args) {
        String str = "221234567";
        //1.验证str是否是三位数字
        System.out.println("1." + str.matches("\\d{3}"));
        //2.验证str是否是2位数数字以及以上
        System.out.println("2." + str.matches("\\d{2,}"));
        //3.验证str是否是手机号： str = "13813183388";
        System.out.println("3." + str.matches("1[3|6|8]\\d{9}"));
        //4.验证小数:必须出现小数点，但是只能出现1次
        // 3.1  4.25 1314.1516
        System.out.println("4." + str.matches("\\d+\\.\\d+"));
        //5.验证小数：小数点可以不出现，也可以出现1次
        System.out.println("5." + str.matches("\\d+\\.?\\d+"));
        //6.验证小数：要求匹配：3、3.、3.14、+3.14、-3. s2 = "-3.";
        System.out.println("6." + str.matches("[+-]\\d+\\.?\\d*"));
        //7.验证qq号码：1).5--15位；2).全部是数字;3).第一位不是0
        System.out.println("7." + str.matches("[1-9]\\d{4,14}"));
    }
}

6. 正则表达式-分组括号( )

/**
 * 正则表达式-分组()
 */
public class TestDemo06 {
    public static void main(String[] args) {
        String str = "DG8FV-B9TKY-FRT9J-99899-XPQ4G";
        //验证这个序列号：分为5组，每组之间使用-隔开，每组由5位A-Z或者0-9的字符组成
        System.out.println(str.matches("([A-Z0-9]{5}-){4}[A-Z0-9]{5}"));
    }
}

7. String的split方法
   public String[] split(String regex); 可以使用正则表达式来切换字符串

/**
 * 正则表达式-split方法
 */
public class TestDemo07 {
    public static void main(String[] args) {
        String str = "18,,4,,,567,,,,99,56";
        //切割
        String[] nums = str.split(",+");
        //打印
        for (String num : nums) {
            System.out.println(num);
        }
    }
}

8. String类的replaceAll方法
   public String replaceAll(String regex,String newStr);//将当前字符串中的旧串替换为新串,其他旧串可以使用正则去匹配

/**
 * 正则表达式-replaceAll
 */
public class TestDemo08 {
    public static void main(String[] args) {
        //将下面字符串中的"数字"替换为"*"
        String str = "jfdk432jfdk2jk24354j47jk5l31324";
        
        //将每个数字,都替换为一个*号
        String newStr1 = str.replaceAll("\\d", "*");
        System.out.println(newStr1);
        //将所有相邻的数字,只替换为一个*
        String newStr2 = str.replaceAll("\\d+", "*");
        System.out.println(newStr2);
    }
}

总结

能够定义枚举
    定义:
    public enum 枚举名{
    枚举项1,枚举项2,枚举项3....枚举项n;
 }
    枚举名 变量名 = 枚举名.枚举项1;
    Sex sex = Sex.MALE;

能够使用四种方法的引用
   集合对象.foreach(System.out::println); 
   其他方式我们作为了解,可以参考"方法引用完整版扩展视频"

能够使用Base64对基本数据、URL和MIME类型进行编解码
    public String encodeToString(byte[] bs);
    public byte[] decode(String str);  

能够理解正则表达式的作用
    "匹配"字符串

能够使用正则表达式的字符类
    [abc][^abc][0-9][a-z][A-Z][0-9a-zA-Z][a-dm-px-z]

能够使用正则表达式的逻辑运算符
    && |

能够使用正则表达式的预定义字符类
    \\d  \\w 

能够使用正则表达式的数量词
    X?
    X*
    X+
    X{n}
    X{n,}
    X{n,m}

能够使用正则表达式的分组
    (...){2}

能够在String的split方法中使用正则表达式

能够在String的replaceAll方法中使用正则表达式