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

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

4/2day24_枚举 _JDK8特性 _正则表达式
JDK8新特性介绍
JDK8的新特性——Lambda表达式的奇淫技巧
jackson parser LocalDataTime 问题
面试
探秘 Java 中的枚举（enum）
枚举：使用小汇总
@FunctionalInterface函数式接口
Java8特性之时间API
jdk8特性

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特性 _正则表达式复习今日内容 1.枚举(在Java中用的是很多的)2.JDK8的...
JDK8新特性介绍
JDK8新特性介绍 JDK8新特性： 1，Lambda表达式 2，新的日期API 3，引入Optional...
JDK8的新特性——Lambda表达式的奇淫技巧
前言 JDK8已经发布快4年的时间了，现在来谈它的新特性显得略微的有点“不合时宜”。尽管JDK8已不再“新”，但它...
jackson parser LocalDataTime 问题
jackson parser LocalDataTime 问题 LocalDataTime 是 jdk8 的新特性...
面试
sql语句 jdk8新特性 lamed 测试单元测试
探秘 Java 中的枚举（enum）
本文包括：枚举由来如何使用？枚举类特性单例设计模式定义特殊结构枚举星期输出中文的案例枚举类API 枚举（enum）...
枚举：使用小汇总
枚举enum是同class，interface同一级别的特性。枚举enum不能被继承。枚举示例：有人说枚举就...
@FunctionalInterface函数式接口
JDK8新特性：函数式接口@FunctionalInterface的使用说明
Java8特性之时间API
JDK8特性之时间API LocalDate、LocalDateTIme、LocalTIme 方法描述now()/...
jdk8特性
最近写java就把jdk8的特性复习了复习做个总结,想想9的模块化10的zgc还有后面新版本的http客户端之类的...

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

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

复习

今日内容

枚举

枚举的作用与应用场景

枚举的基本语法

JDK8的其他新特性

方法引用

方法引用概述

方法引用基本使用格式

System.out.println的引用

Base64

Base64概述

Base64的内嵌类和方法

Base64演示

正则表达式

正则表达式概念

正则表达式-字符类

正则表达式-逻辑运算符

正则表达式-预定义字符

正则表达式-数量词

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

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

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

今日总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读