4/2day24_枚举 _JDK8特性 _正则表达式

作者: 蹦蹦跶跶的起床啊 | 来源:发表于2020-04-03 00:27 被阅读0次

day24_枚举 _JDK8特性 _正则表达式

复习

复习:动态代理
    a.给为一个目标类对象,在程序运行期间,动态的生成一个代理类对象
    b.代理类对象可以拦截调用所有方法,可以根据我们的需求对方法进行增强,减弱,直接不让调用
    c.动态代理回顾:
    public class DynamicProxyDemo {
    public static void main(String[] args) {
        //1.ArrayList
        ArrayList<String> list = new ArrayList<String>();
        list.add("java");
        list.add("php");
        list.add("c++");
        //2.使用动态代理
        List<String> listProxy = (List<String>) Proxy.newProxyInstance(DynamicProxyDemo.class.getClassLoader(), list.getClass().getInterfaces(), new InvocationHandler() {
            //我们调用生成的代理对象的任何方法,都会被invoke方法拦截!!
            //Object proxy 代理对象(我们一般用不到)
            //Method method 拦截到的方法
            //Object[] args 拦截到的方法的参数
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //按照我们自己的需求
                String name = method.getName();
                //1.拦截add方法
                if ("add".equals(name)) {
                    throw new UnsupportedOperationException("暂时不支持添加操作!");
//                    System.out.println("暂时不支持添加操作!");
                } else {
                    //2.别的方法直接调用真实对象的方法
                    Object v = method.invoke(list,args);
                    return v;
                }
            }
        });
        //3.试一试
        listProxy.add("android");
        String str = listProxy.get(1);
        System.out.println(str);
    }
}

今日内容

1.枚举(在Java中用的是很多的)
2.JDK8的新特性(默认方法,Lambda,Stream流)
了解即可: 方法引用,Base64用于字符串编码
3.正则表达式(理解)

枚举

不使用枚举存在的问题：可以给性别传入任意的字符串，导致性别是非法的数据，不安全。

枚举的作用与应用场景

枚举的作用：就是把所有可能的情况列举出来.

使用场景: 一个方法接收的参数是固定范围之内的时候，那么即可使用枚举。

枚举的基本语法

定义枚举的格式

public enum 枚举名 {
    第一行都是罗列枚举实例,这些枚举实例直接写大写名字即可。
}

案例

定义枚举：BOY表示男，GIRL表示女

enum Sex {
    BOY, GIRL; // 男，女
}

Perosn中的性别有String类型改为Sex枚举类型

public class Person {
    private String name;
    private Sex sex;
 
    public Person() {
    }
 
    public Person(String name, Sex sex) {
        this.name = name;
        this.sex = sex;
    }
    // 省略get/set/toString方法
}

使用是只能传入枚举中的固定值

public class Demo02 {
    public static void main(String[] args) {
        Person p1 = new Person("张三", Sex.BOY);
        Person p2 = new Person("张三", Sex.GIRL);
    }
}

枚举的本质

枚举会被jvm编译后, 枚举的本质是个类, 枚举项就是该类的对象

enum SEX {
    BOY, GIRL; // 男，女  
}
 
// 枚举的本质是一个类，我们刚才定义的Sex枚举相当于下面的类
final class SEX extends java.lang.Enum<SEX> {
    public static final SEX BOY = new SEX();//这里默认调用的是无参构造
    public static final SEX GIRL = new SEX();
    public static SEX[] values();
    public static SEX valueOf(java.lang.String);
    static {};
}

枚举可以有成员方法, 成员变量等

public enum Sex {
    BOY(18), GIRL(16);//这里默认是jvm进行了创建了Sex类的一个BOY对象,默认调用无参构造, 这里加上参数, 代表调用有参构造
 
    public int age;
 
    Sex(int age) {
        this.age = age;
    }
 
    public void showAge() {
        System.out.println("年龄是: " + age);
    }
}

public class Demo03 {
    public static void main(String[] args) {
        Person p1 = new Person("张三", Sex.BOY);
        Person p2 = new Person("张三", Sex.GIRL);
 
        Sex.BOY.showAge();// BOY是枚举项相当于是JVM编译后 Sex类的一个对象, 所以可以当做 对象调用该对象类的成员方法
        Sex.GIRL.showAge();
    }
}

JDK8的其他新特性

JDK新特性：
Lambda 表达式【已学习过】
默认方法【已学习过】
Stream API 【已学习过】
方法引用
Base64

方法引用

方法引用概述

方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象

如下类名引用静态方法, 对象名引用方法

public class MethodReferencesDemo {
    public static void main(String[] args) {
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        }).start();

        new Thread(new MyRunnable()).start();

        new Thread(() -> System.out.println("shiyixia")).start();
        //类引用静态方法
        new Thread(Dog::bark).start();
        //对象引用方法
        new Thread(new Dog()::bark1).start();

    }
}
class Dog {
    public static void bark() {
        System.out.println("犬吠");
    }
    public  void bark1() {
        System.out.println("犬吠");
    }
}
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("");
    }
}

方法引用基本使用格式

通过类名引用存在的静态方法

类名 :: 静态方法名
通过对象引用存在的非静态方法

对象名 :: 普通方法名
通过类名引用构造方法

类名 :: new // Person :: new
通过数组引用其构造方法

数据类型[] :: new // int[10] :: new int[] arr =new int[10]

System.out.println的引用

public class SystemOutDemo {
    public static void main(String[] args) {
        List names = new ArrayList();
        names.add("大明");
        names.add("二明");
        names.add("小明");
        names.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

        names.stream().forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

        names.forEach(o -> System.out.println(o));

        names.forEach(System.out::println);
    }
}

Base64

Base64概述

一种常见的编码方法

Base64的内嵌类和方法

Decoder和Encoder
UrlDecoder和UrlEncoder
MimeDecoder和MimeDecoder

String encodeToString(byte[] bs); //编码
byte[] decode(String str);//解码

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));
    }
}

正则表达式

正则表达式概念

本质是个字符串, 这个字符串里边的各个符号代表了规则

正则表达式-字符类

[abc]：代表a或者b，或者c字符中的一个。
[^abc]：代表除a,b,c以外的任何字符。
[a-z]：代表a-z的所有小写字符中的一个。
[A-Z]：代表A-Z的所有大写字符中的一个。
[0-9]：代表0-9之间的某一个数字字符。
[a-zA-Z0-9]：代表a-z或者A-Z或者0-9之间的任意一个字符。
[a-dm-p]：a 到 d 或 m 到 p之间的任意一个字符。

正则表达式-逻辑运算符

&&：并且
| ：或者

正则表达式-预定义字符

"." ：匹配任何字符。
"\d"：任何数字[0-9]的简写；
"\D"：任何非数字[^0-9]的简写；
"\s"：空白字符：[ \t\n\x0B\f\r] 的简写
"\S"：非空白字符：[^\s] 的简写
"\w"：单词字符：[a-zA-Z_0-9]的简写
"\W"：非单词字符：[^\w]

public class Demo {
    public static void main(String[] args) {
        String str = "258";
        
        //1.验证str是否3位数字
        String regex = "\\d\\d\\d";
        System.out.println("1." + str.matches(regex));
        
        //2.验证手机号：1开头，第二位：3/5/8，剩下9位都是0-9的数字
        str = "13513153355";//要验证的字符串
        regex = "1[358]\\d\\d\\d\\d\\d\\d\\d\\d\\d";//正则表达式
        System.out.println("2." + str.matches(regex));
        
        //3.验证字符串是否以h开头，以d结尾，中间是任何字符
        str = "had";//要验证的字符串
        regex = "h.d";//正则表达式
        System.out.println("3." + str.matches(regex));
        
        //4.验证str是否是：had.
        str = "had.";//要验证的字符串
        regex = "had\\.";//\\.代表'.'符号，因为.在正则中被预定义为"任意字符"，不能直接使用
        System.out.println("4." + str.matches(regex));
        
    }
}

正则表达式-数量词

X? : 0次或1次
X* : 0次到多次
X+ : 1次或多次
X{n} : 恰好n次
X{n,} : 至少n次
X{n,m}: n到m次(n和m都是包含的)

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

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

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

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

public String[] split(String regex)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的符号作为"分隔符"来切割字符串。

public class Demo {
    public static void main(String[] args) {
        String str = "18  4 567       99     56";
        String[] strArray = str.split(" +");
        for (int i = 0; i < strArray.length; i++) {
            System.out.println(strArray[i]);
        }
    }
}

String类的replaceAll方法中使用正则表达式

public String replaceAll(String regex,String newStr)//参数regex就是一个正则表达式。可以将当前字符串中匹配regex正则表达式的字符串替换为newStr。

public class Demo {
    public static void main(String[] args) {
        //将下面字符串中的"数字"替换为"*"
        String str = "jfdk432jfdk2jk24354j47jk5l31324";
        System.out.println(str.replaceAll("\\d+", "*"));
    }
}

今日总结

枚举

概述：   
  枚举是一种特殊类，是有固定实例个数的类型。
    我们可以把枚举理解成有固定的实例个数的多例模式。
    
格式：
  修饰符 enum 枚举名{
      枚举值;
  }
  
特点：
  1.枚举实质上还是类，所有的枚举类型隐性地继承自java.lang.Enum。
  2.因为java的单继承，所以枚举类无法继承其他类，而且枚举类默认是final修饰的，也无法被继承。
  3.枚举的成员实质就是一个枚举类型的对象，他们默认都是public static final修饰的。
  4.枚举的本质是一个类，所以枚举中还可以有成员变量，成员方法，构造方法等。（大多数情况不会加其他成员）
  5.枚举是不能在外部创建对象的，枚举的构造器默认是私有的。
  

枚举方式实现单例
//枚举类本身就是final类型的，不允许被继承
public enum Singleton{
  //创建实例对象
  INSTANCE;
  
  //提供获得对象的静态方法
  public static Single getInstance(){
      return INSTANCE;
  }
}

Base64 编码

Base64编码特点：
    1.Base64是编码,不算加密,Base64编码算法简单, 几乎不会影响效率。
    2.编码后会增加字节数，字节数会成为原字节数的4/3; 
      即把3个字节变成4个可打印字符，所以base64编码后的字符串一定能被4整除。
    3.算法可逆, 解码很方便, 不用于私密信息通信。
    4.编码后的字符串只包含[0-9a-zA-Z+/]字符内容,等号(==)一般是作为后缀出现。


Base64操作API：
    1.普通字符串编解码：
        getEncoder()：返回一个基本编码器
        getDecoder()：返回一个基本解码器

    2.URL地址编解码：
        getUrlEncoder()：返回一个URL编码方案的编码器
        getUrlDecoder()：返回一个URL解码方案的解码器
           
    3.MIME文本编解码：
        getMimeEncoder()：返回一个MIME型的编码器
        getMimeDecoder()：返回一个MIME型的解码器


  4.编码: byte[] en = encode(byte[] src)
      解码: byte[] de = decode(byte[] en)

正则表达式

表达式语法

1.预定义字符(元字符)
    "." ： 匹配字符。
    "\d"： 匹配数字 
    "\D"： 匹配非数字
    "\s"： 匹配空白字符 
    "\S"： 匹配非空白字符
    "\w"： 匹配单词字符 
    "\W"： 匹配非单词字符


2.区间匹配 []
  [abc]： 匹配abc的其中一个。
  [^abc]：匹配除a,b,c以外的任何字符。

  [a-z]：匹配小写字母a-z中的一个。
  [A-Z]：匹配大写字母A-Z中的一个。
  [0-9]：匹配数字0-9中的一个。
  
  [\u4e00-\u9fa5]: 匹配常见的汉字
  
  组合匹配：
  [a-zA-Z0-9]：匹配a-z或者A-Z或者0-9之间的任意一个字符。
  [a-dm-p]： 匹配a-d或m-p之间的任意一个字符。


3.数量匹配
    *   0次到多次 (任意次)
    ?   0次到1次 (有或没有)
    +   1次到多次
    {n}    重复n次
    {n,}   重复n次以上 (>=n次)
    {n,m}  重复n到m次
    

4.逻辑判断
    && ：并且
    |  ：或者
    
    
5.括号分组 ()
    正则表达式中用小括号()来做分组，也就是括号中的内容作为一个整体。


6.常见匹配规则：
    验证是否三位数字："\\d{3}"
    验证是否两位以上数字："\\d{2,}"
    匹配手机号码："1[3|5|6|8]\\d{9}"  
    匹配小数(必须有小数点)："\\d+\\.\\d+" 
    验证qq号码(5-15位数字，不能0开头): "[1-9]\\d{4,14}"
    
    ip地址匹配: "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";

    邮箱匹配："[a-zA-Z0-9_]+@[0-9A-Za-z]+(\\.[a-zA-Z]+)+"
        
    /*
         @前 数字字母_ 个数不少于1个
         @后 数字字母  个数不少于一个
         .   后面 字母 
    */


查询匹配规则网站：
http://tool.chinaz.com/regex

常用操作API

String类支持正则表达式的API
1、匹配判断
    matches("正则表达式")

2、匹配后替换
    replaceAll("正则表达式","新内容")
    注意：我们之前学的replace方法的参数只能是普通字符串，不能匹配正则表达式

3、字符串切割
    split("正则表达式")
        

Java提供了功能强大的正则表达式API，在java.util.regex包下。
Pattern类
  1.正则表达式经编译后的表现模式，必须先将字符串类型的正则表达式编译成此实例。
      Pattern p = Pattern.compile("正则表达式");
    2.获取匹配器对象。
       Matcher matcher = p.matcher("要匹配的字符串");

Matcher类
  匹配器，可以根据Pattern的匹配规则操作匹配的字符串。   
  public boolean find() 
      //在目标字符串里查找下一个匹配子串。
    
    public String group()
      //返回与整个表达式匹配的子串内容。
    
    public String group(int group)
      //返回指定分组匹配的子串内容。

练习1：匹配下面短信文本中的验证码，并取出。
【验证码】您的登录验证码是: 69598，如非本人操作，请忽略本消息，该验证码15分钟后失效。


练习2：匹配下面文本中的日期，并取出。
版本号：V4.10.19更新日期：2020-04-01 20:52
    
//练习1
@Test
public void test1() {
    String s = 
        "【验证码】您的登录验证码是: 69598，如非本人操作，请忽略本消息，该验证码15分钟后失效。";
    //获取正则模板
    Pattern p = Pattern.compile("\\d{5}");
    //获取匹配器
    Matcher mc = p.matcher(s);
    //判断是否匹配成功
    if(mc.find()){
        //取出整个字符串中所有匹配的内容
        String code = mc.group();
        System.out.println(code);
    }
}



//练习2
@Test
public void test2() {
    String s = "版本号：V4.10.19更新日期：2020-04-01 20:52";
    //获取正则模板
    Pattern p = Pattern.compile("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}");
    //获取匹配器
    Matcher mc = p.matcher(s);
    //判断是否匹配成功
    if(mc.find()){
        //取出整个字符串中所有匹配的内容
        String code = mc.group();
        System.out.println(code);
    }
}

4/2day24_枚举 _JDK8特性 _正则表达式

day24_枚举 _JDK8特性 _正则表达式

复习

今日内容

枚举

枚举的作用与应用场景

枚举的基本语法

JDK8的其他新特性

方法引用

方法引用概述

方法引用基本使用格式

System.out.println的引用

Base64

Base64概述

Base64的内嵌类和方法

Base64演示

正则表达式

正则表达式概念

正则表达式-字符类

正则表达式-逻辑运算符

正则表达式-预定义字符

正则表达式-数量词

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

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

String类的replaceAll方法中使用正则表达式

今日总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读