day29【枚举-正则-jdk8新特性】课上

一.枚举

  枚举:
    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());*/  ->所有枚举类的父类都是Enum,调用的是Enum中的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=
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);
        }
    }
}

8.正则表达式生成网址:

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

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

- Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64里面提供了3种编码解码方式，能够在网络传输字节码时对字节进行编码和解码。

- 在Java 8中，Base64编码已经成为Java类库的标准。
- Java 8 内置了 Base64 编码的编码器和解码器。
- Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

  - **基本：**最基本编码和解码方式。
  - **URL：**表示对浏览器中的地址栏进行编码和解码。编码后对特殊字符有处理，比如编码后没有/ 这个字符
  - **MIME：**编码后字符串每行最多76个字符

• 基本编码解码：

  使用Base64类调用类中的静态方法来获取解码器和编码器：

序号	方法名 & 描述
1	**static Base64.Encoder getEncoder()**返回一个 Base64.Encoder ，获取编码器
2	**static Base64.Decoder getDecoder()**返回一个 Base64.Decoder ，获取解码器

Base64.Encoder类中的编码方法：

String encodeToString(byte[] src) 编码

Base64.Decoder类中的解码方法：

byte[] decode(String src) 解码 

代码演示：

public class Test05 {                                                             
    public static void main(String[] args) {                                      
        //基本方式                                                                    
        //获取编码器                                                                   
        Base64.Encoder encoder = Base64.getEncoder();                             
        //获取解码器                                                                   
        Base64.Decoder decoder = Base64.getDecoder();                             
                                                                                  
        //演示效果                                                                    
        String s = "suoge123456789";                                              
        //编码                                                                      
        String s1 = encoder.encodeToString(s.getBytes());                         
                                                                                  
        System.out.println("编码前"   + s );   // 编码前suoge123456789                  
        System.out.println("编码后"   + s1 );  // 编码后c3VvZ2UxMjM0NTY3ODk=            
                                                                                  
        //解码                                                                      
        byte[] bytes = decoder.decode(s1);                                        
        System.out.println("解码后" + new String(bytes));  // 解码后suoge123456789      
    }                                                                             
}                                                                                 

• URL:

  使用Base64类调用类中的静态方法来获取解码器和编码器：

序号	方法名 & 描述
1	**static Base64.Encoder getUrlEncoder()**返回一个 Base64.Encoder ，获取编码器
2	**static Base64.Decoder getUrlDecoder()**返回一个 Base64.Decoder ，获取解码器

Base64.Encoder类中的编码方法：

String encodeToString(byte[] src) 编码

Base64.Decoder类中的解码方法：

byte[] decode(String src) 解码 

说明：

编码后对特殊字符有处理，比如在下面的案例中，编码后没有/ 这个字符。

{“广州”:“020”}

public class Test05 {
    public static void main(String[] args) {
        //URL方式
        //获取编码器
        Base64.Encoder encoder = Base64.getUrlEncoder();
        //获取解码器
        Base64.Decoder decoder = Base64.getUrlDecoder();

        //演示效果
       //String s = "{\"广州\":\"020\"}";
        
         String s = "{"+"广州"+":"+"020"+"}";
        //编码
        String s1 = encoder.encodeToString(s.getBytes());

        System.out.println("编码前" + s);//编码前{"广州":"020"}
        System.out.println("编码后" + s1);//编码后eyLlub_lt54iOiIwMjAifQ==

        //解码
        byte[] bytes = decoder.decode(s1);
        System.out.println("解码后" + new String(bytes));//解码后{"广州":"020"}
    }
}

• MIME:编码后字符串每行最多76个字符

使用Base64类调用类中的静态方法来获取解码器和编码器：

序号	方法名 & 描述
1	**static Base64.Encoder getMimeEncoder()**返回一个 Base64.Encoder ，获取编码器
2	**static Base64.Decoder getMimeDecoder()**返回一个 Base64.Decoder ，获取解码器

Base64.Encoder类中的编码方法：

String encodeToString(byte[] src) 编码

Base64.Decoder类中的解码方法：

byte[] decode(String src) 解码 

public class Test05 {
    public static void main(String[] args) {
        //MIME方式
        //获取编码器
        Base64.Encoder encoder = Base64.getMimeEncoder();
        //获取解码器
        Base64.Decoder decoder = Base64.getMimeDecoder();
        //演示效果
        String s = "";
        for(int i=0; i<100; i++){
            s += i;
        }
        //编码
        String s1 = encoder.encodeToString(s.getBytes());

        System.out.println("编码前"   + s );
        System.out.println("编码后"   + s1 );

        //解码
        byte[] bytes = decoder.decode(s1);
        System.out.println("解码后" + new String(bytes));
    }
}

四.方法引用

一.方法引用的介绍

1.概述:用于简化Lambda表达式的一个JDK新特性
2.注意:局限性非常小(由于Lambda表达式已经很局限了)
3.使用前提:
  a.在重写函数式接口的方法中使用方法引用
  b.引用的方法要和函数式接口中的抽象方法从参数上,返回值上一样(类型,个数)

二.方法引入的体验

package com.itheima.demo05;

import java.util.function.Consumer;

/*
    方法引用:
        JDK1.8之后出现的新特性,用于简化Lambda表达式
        当一些内容已经存在了,我们就可以使用方法引用,直接引用这些内容
 */
public class Demo01 {
    public static void main(String[] args) {
        //调用method方法,方法的参数Consumer是一个函数式接口,所以我们可以使用Lambda表达式作为接口库的实现类
        method((String s)->{
            System.out.println(s);
        },"abc");

        //简化的Lambda表达式
        method(s-> System.out.println(s),"abc");

        /*
            Lambda表达式的目的:传递一个参数s,对参数s进行输出
            输出语句中的System.out对程序(PrintStream)是已经存在的
            PrintStream对象中的方法println也是已经存在的
            就可以使用方法引用来简化lambda表达式,直接使用对象引用成员方法,来输出字符串
            格式:
                对象名::成员方法
         */
        method(System.out::println,"abc");
    }
    
    
    /*
        定义一个方法,方法的参数
            传递Consumer接口,泛型使用String
            传递一个字符串
        在方法内部使用Consumer接口中的方法accept对字符串进行消费
     */
    public static void method(Consumer<String> con, String s){
        con.accept(s);//至于怎么消费字符串,写在Lambda表达式中
    }
}

三.对象名–引用成员方法

package com.itheima.demo06;

import java.util.function.Supplier;

/*
    使用对象名引用成员方法
    格式:
        对象名::成员方法名
    当对象和成员方法都是已经存在的时候,就可以使用对象名来引用成员方法

    函数式接口:Supplier
        java.util.function.Supplier接口
    抽象方法:
        T get()。用来获取一个泛型参数指定类型的对象数据。
        Supplier接口使用什么泛型,就可以使用get方法获取一个什么类型的数据
 */
public class Demo01 {
      public static void main(String[] args) {
        //调用method方法,方法的参数Supplier是一个函数式接口,所以我们可以使用Lambda表示作为接口的实现类对象
        method(()->{
            //返回一个大写的字符串
            return "abc".toUpperCase();
        });

        //简化Lambda
        method(()->"abc".toUpperCase());

        /*
            字符串对象"abc"是已经存在的
            字符串中的方法toUpperCase是已经存在的
            使用字符串"abc"直接引用成员方法toUpperCase
                对象名::成员方法
         */
        method("abc"::toUpperCase);
        method("abc"::toLowerCase);
    }
    /*
        定义一个方法,方法的参数
            传递Supplier接口,泛型使用String
        方法的内部使用Supplier接口中的方法get获取一个字符串
     */
    public static void method(Supplier<String> sup){
        String s = sup.get();
        System.out.println(s);
    }
}

四.类名–引用静态方法

package com.itheima.demo06;

import java.util.function.Supplier;

/*
    类名--引用静态方法
    格式:
        类名::静态成员方法
    如果类和静态成员方法是已经存在的,那么就可以使用类名直接引用静态成员方法
 */
public class Demo02 {

    public static void main(String[] args) {
        //调用method方法,方法的参数Supplier是一个函数式接口,所以我们可以使用Lambda表示作为接口的实现类对象
        method(()->{
            //返回一个随机的小数
            return Math.random();//[0.0-1.0)
        });

        //简化Lambda
        method(()->Math.random());

        /*
            Math数学工具类是已经存在的
            random静态方法是已经存在的
            可以直接使用Math类名引用静态成员方法简化Lambda表达式
         */
        method(Math::random);
    }
    
    /*
        定义一个方法,方法的参数
            传递Supplier接口,泛型使用Double
        方法的内部使用Supplier接口中的方法get获取一个小数
     */
    public static void method(Supplier<Double> sup){
        Double d = sup.get();
        System.out.println(d);
    }

}

五.类–构造引用

package com.itheima.demo06;

public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.itheima.demo06;

import java.util.function.Function;

/*
    类--构造方法引用
    格式:
        构造方法名称::new
    如果类中的构造方法是已经存在的,使用构造方法直接引用new关键字来创建对象

    函数式接口:Function
        java.util.function.Function接口
    抽象方法:
        R apply(T t)，根据类型T的参数获取类型R的结果。用于数类型转换
 */
public class Demo03 {
   
    public static void main(String[] args) {
        //调用method方法,方法的参数Function是一个函数式接口,所以可以使用Lambda表达式最为接口的实现类对象
        method((String s)->{
            return new Person(s);
        },"小明");

        //简化Lambda表达式
        method(s->new Person(s),"小花");

        /*
            Lambda表达式的目的:就是根据字符串的名字,创建对象
            创建对象的带参数构造方法是已经存在的
            创建对象使用的关键字new已经存在的
            所以就可以直接使用构造方法引用new创建对象
                构造方法名称:new
         */
        method(Person::new,"柳岩");
    }
    
     /*
        定义一个方法,方法的参数
            传递函数式接口Function,泛型使用
            传递字符串
        方法内部使用Function接口中的额方法apply,把字符串转换为Person对象返回
     */
    public static void method(Function<String,Person> fun,String name){
        Person p = fun.apply(name);
        System.out.println(p);
    }

}

六.数组–构造引用

package com.itheima.demo06;


import java.util.Arrays;
import java.util.function.Function;

/*
    数组--构造引用
    格式:
        数组的数据类型[]::new
        int[]::new 创建一个int类型的数组
        double[]::new 创建一个double类型的数组
 */
public class Demo04 {
   
    public static void main(String[] args) {
        //调用method方法,方法的参数Function是一个函数式接口,所以可以使用Lambda表达式最为接口的实现类对象
        method((Integer length)->{
            //根据数组的长度,创建一个指定长度的数组返回
            return new int[length];
        },10);

        //简化Lambda表达式
        method(len->new int[len],10);

        /*
            Lambda表达式的目的:创建一个指定长度的数组
            数组的数据类型已经存在int
            数组的长度也是已经存在的
            使用方法引用简化Lambda表达式
                int[]::new
            使用int[]数组引用new,根据长度创建数组返回
         */
        method(int[]::new,10);
    }
    
     /*
        定义一个方法,方法的参数
            传递Function接口,泛型使用
            传递int类型的数组长度
            在方法内部使用Function接口中的方法apply,[根据数组的长度,创建一个指定长度的数组返回]
     */
    public static void method(Function<Integer,int[]> fun, int length){
        int[] arr = fun.apply(length);
        System.out.println(Arrays.toString(arr));
    }

}

七.方法引用在Stream流中的使用(重点)

package com.itheima.demo06;

import java.util.stream.Stream;

/*
    方法引用在Stream流中的使用
 */
public class Demo05 {
    public static void main(String[] args) {
        //获取一个Stream流
        Stream<String> stream = Stream.of("a", "b", "c", "d", "e");
        //遍历Stream流
        //stream.forEach(s-> System.out.println(s));
        stream.forEach(System.out::println);
    }

}