美文网首页
4/2day24_枚举 _JDK8特性 _正则表达式

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 枚举名 {
        第一行都是罗列枚举实例,这些枚举实例直接写大写名字即可。
    }
    
  • 案例

    1. 定义枚举:BOY表示男,GIRL表示女
    enum Sex {
        BOY, GIRL; // 男,女
    }
    
    1. 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方法
    }
    
    1. 使用是只能传入枚举中的固定值
    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));
    }
}

正则表达式

正则表达式概念

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

正则表达式-字符类

  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之间的任意一个字符。

正则表达式-逻辑运算符

  1. &&:并且
  2. | :或者

正则表达式-预定义字符

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

正则表达式-数量词

  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) {
        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特性 _正则表达式

      本文链接:https://www.haomeiwen.com/subject/aniqphtx.html