Java学习day21-JDK新特性

Java学习day21-JDK新特性

陳先森 292 2021-10-27

1.Lambda表达式

1.1体验Lambda表达式【理解】

  • 案例需求

    启动一个线程,在控制台输出一句话:多线程程序启动了

  • 实现方式一

    • 实现步骤
      • 定义一个类MyRunnable实现Runnable接口,重写run()方法
      • 创建MyRunnable类的对象
      • 创建Thread类的对象,把MyRunnable的对象作为构造参数传递
      • 启动线程
  • 实现方式二

    • 匿名内部类的方式改进
  • 实现方式三

    • Lambda表达式的方式改进
  • 代码演示

    //方式一的线程类
    public class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            System.out.println("多线程程序启动了");
        }
    }
    
    public class LambdaDemo {
        public static void main(String[] args) {
            //方式一
    //        MyRunnable my = new MyRunnable();
    //        Thread t = new Thread(my);
    //        t.start();
    
            //方式二
    //        new Thread(new Runnable() {
    //            @Override
    //            public void run() {
    //                System.out.println("多线程程序启动了");
    //            }
    //        }).start();
    
            //方式三
            new Thread( () -> {
                System.out.println("多线程程序启动了");
            } ).start();
        }
    }
    
  • 函数式编程思想概述

    函数式思想则尽量忽略面向对象的复杂语法:“强调做什么,而不是以什么形式去做”

    而我们要学习的Lambda表达式就是函数式思想的体现

1.2Lambda表达式的标准格式【理解】

  • 格式:

    ​ (形式参数) ->

    • 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可

    • ->:由英文中画线和大于符号组成,固定写法。代表指向动作

    • 代码块:是我们具体要做的事情,也就是以前我们写的方法体内容

  • 组成Lambda表达式的三要素:

    • 形式参数,箭头,代码块

1.3Lambda表达式练习1【应用】

  • Lambda表达式的使用前提

    • 有一个接口

    • 接口中有且仅有一个抽象方法

  • 练习描述

    ​ 无参无返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Eatable),里面定义一个抽象方法:void eat();

    • 定义一个测试类(EatableDemo),在测试类中提供两个方法

      • 一个方法是:useEatable(Eatable e)

      • 一个方法是主方法,在主方法中调用useEatable方法

  • 示例代码

    //接口
    public interface Eatable {
        void eat();
    }
    //实现类
    public class EatableImpl implements Eatable {
        @Override
        public void eat() {
            System.out.println("一天一苹果,医生远离我");
        }
    }
    //测试类
    public class EatableDemo {
        public static void main(String[] args) {
            //在主方法中调用useEatable方法
            Eatable e = new EatableImpl();
            useEatable(e);
    
            //匿名内部类
            useEatable(new Eatable() {
                @Override
                public void eat() {
                    System.out.println("一天一苹果,医生远离我");
                }
            });
    
            //Lambda表达式
            useEatable(() -> {
                System.out.println("一天一苹果,医生远离我");
            });
        }
    
        private static void useEatable(Eatable e) {
            e.eat();
        }
    }
    

1.4Lambda表达式练习2【应用】

  • 练习描述

    有参无返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Flyable),里面定义一个抽象方法:void fly(String s);

    • 定义一个测试类(FlyableDemo),在测试类中提供两个方法

      • 一个方法是:useFlyable(Flyable f)

      • 一个方法是主方法,在主方法中调用useFlyable方法

  • 示例代码

    public interface Flyable {
        void fly(String s);
    }
    
    public class FlyableDemo {
        public static void main(String[] args) {
            //在主方法中调用useFlyable方法
            //匿名内部类
            useFlyable(new Flyable() {
                @Override
                public void fly(String s) {
                    System.out.println(s);
                    System.out.println("飞机自驾游");
                }
            });
            System.out.println("--------");
    
            //Lambda
            useFlyable((String s) -> {
                System.out.println(s);
                System.out.println("飞机自驾游");
            });
    
        }
    
        private static void useFlyable(Flyable f) {
            f.fly("风和日丽,晴空万里");
        }
    }
    

1.5Lambda表达式练习3【应用】

  • 练习描述

    有参有返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Addable),里面定义一个抽象方法:int add(int x,int y);

    • 定义一个测试类(AddableDemo),在测试类中提供两个方法

      • 一个方法是:useAddable(Addable a)

      • 一个方法是主方法,在主方法中调用useAddable方法

  • 示例代码

    public interface Addable {
        int add(int x,int y);
    }
    
    public class AddableDemo {
        public static void main(String[] args) {
            //在主方法中调用useAddable方法
            useAddable((int x,int y) -> {
                return x + y;
            });
    
        }
    
        private static void useAddable(Addable a) {
            int sum = a.add(10, 20);
            System.out.println(sum);
        }
    }
    

1.6Lambda表达式的省略模式【应用】

  • 省略的规则

    • 参数类型可以省略。但是有多个参数的情况下,不能只省略一个
    • 如果参数有且仅有一个,那么小括号可以省略
    • 如果代码块的语句只有一条,可以省略大括号和分号,和return关键字
  • 代码演示

    public interface Addable {
        int add(int x, int y);
    }
    
    public interface Flyable {
        void fly(String s);
    }
    
    public class LambdaDemo {
        public static void main(String[] args) {
    //        useAddable((int x,int y) -> {
    //            return x + y;
    //        });
            //参数的类型可以省略
            useAddable((x, y) -> {
                return x + y;
            });
    
    //        useFlyable((String s) -> {
    //            System.out.println(s);
    //        });
            //如果参数有且仅有一个,那么小括号可以省略
    //        useFlyable(s -> {
    //            System.out.println(s);
    //        });
    
            //如果代码块的语句只有一条,可以省略大括号和分号
            useFlyable(s -> System.out.println(s));
    
            //如果代码块的语句只有一条,可以省略大括号和分号,如果有return,return也要省略掉
            useAddable((x, y) -> x + y);
        }
    
        private static void useFlyable(Flyable f) {
            f.fly("风和日丽,晴空万里");
        }
    
        private static void useAddable(Addable a) {
            int sum = a.add(10, 20);
            System.out.println(sum);
        }
    }
    

1.7Lambda表达式的注意事项【理解】

  • 使用Lambda必须要有接口,并且要求接口中有且仅有一个抽象方法

  • 必须有上下文环境,才能推导出Lambda对应的接口

    • 根据局部变量的赋值得知Lambda对应的接口

      ​ Runnable r = () -> System.out.println(“Lambda表达式”);

    • 根据调用方法的参数得知Lambda对应的接口

      ​ new Thread(() -> System.out.println(“Lambda表达式”)).start();

1.8Lambda表达式和匿名内部类的区别【理解】

  • 所需类型不同

    • 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
    • Lambda表达式:只能是接口
  • 使用限制不同

    • 如果接口中有且仅有一个抽象方法,可以使用Lambda表达式,也可以使用匿名内部类

    • 如果接口中多于一个抽象方法,只能使用匿名内部类,而不能使用Lambda表达式

  • 实现原理不同

    • 匿名内部类:编译之后,产生一个单独的.class字节码文件
    • Lambda表达式:编译之后,没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

2.接口组成更新

2.1接口组成更新概述【理解】

  • 常量

    public static final

  • 抽象方法

    public abstract

  • 默认方法(Java 8)

  • 静态方法(Java 8)

  • 私有方法(Java 9)

2.2接口中默认方法【应用】

  • 格式

    public default 返回值类型 方法名(参数列表)

  • 范例

    public default void show3() { 
    }
    
  • 注意事项

    • 默认方法不是抽象方法,所以不强制被重写。但是可以被重写,重写的时候去掉default关键字

    • public可以省略,default不能省略

2.3接口中静态方法【应用】

  • 格式

    public static 返回值类型 方法名(参数列表)

  • 范例

    public static void show() {
    }
    
  • 注意事项

    • 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用

    • public可以省略,static不能省略

2.4接口中私有方法【应用】

  • 私有方法产生原因

    Java 9中新增了带方法体的私有方法,这其实在Java 8中就埋下了伏笔:Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题:当两个默认方法或者静态方法中包含一段相同的代码实现时,程序必然考虑将这段实现代码抽取成一个共性方法,而这个共性方法是不需要让别人使用的,因此用私有给隐藏起来,这就是Java 9增加私有方法的必然性

  • 定义格式

    • 格式1

      private 返回值类型 方法名(参数列表)

    • 范例1

      private void show() {  
      }
      
    • 格式2

      private static 返回值类型 方法名(参数列表)

    • 范例2

      private static void method() {  
      }
      
  • 注意事项

    • 默认方法可以调用私有的静态方法和非静态方法
    • 静态方法只能调用私有的静态方法

3.方法引用

3.1体验方法引用【理解】

  • 方法引用的出现原因

    在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿参数做操作

    那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑呢?答案肯定是没有必要

    那我们又是如何使用已经存在的方案的呢?

    这就是我们要讲解的方法引用,我们是通过方法引用来使用已经存在的方案

  • 代码演示

    public interface Printable {
        void printString(String s);
    }
    
    public class PrintableDemo {
        public static void main(String[] args) {
            //在主方法中调用usePrintable方法
    //        usePrintable((String s) -> {
    //            System.out.println(s);
    //        });
    	    //Lambda简化写法
            usePrintable(s -> System.out.println(s));
    
            //方法引用
            usePrintable(System.out::println);
    
        }
    
        private static void usePrintable(Printable p) {
            p.printString("爱生活爱Java");
        }
    }
    
    

3.2方法引用符【理解】

  • 方法引用符

    :: 该符号为引用运算符,而它所在的表达式被称为方法引用

  • 推导与省略

    • 如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式,它们都将被自动推导
    • 如果使用方法引用,也是同样可以根据上下文进行推导
    • 方法引用是Lambda的孪生兄弟

3.3引用类方法【应用】

​ 引用类方法,其实就是引用类的静态方法

  • 格式

    类名::静态方法

  • 范例

    Integer::parseInt

    Integer类的方法:public static int parseInt(String s) 将此String转换为int类型数据

  • 练习描述

    • 定义一个接口(Converter),里面定义一个抽象方法 int convert(String s);

    • 定义一个测试类(ConverterDemo),在测试类中提供两个方法

      • 一个方法是:useConverter(Converter c)

      • 一个方法是主方法,在主方法中调用useConverter方法

  • 代码演示

    public interface Converter {
        int convert(String s);
    }
    
    public class ConverterDemo {
        public static void main(String[] args) {
    
    		//Lambda写法
            useConverter(s -> Integer.parseInt(s));
    
            //引用类方法
            useConverter(Integer::parseInt);
    
        }
    
        private static void useConverter(Converter c) {
            int number = c.convert("666");
            System.out.println(number);
        }
    }
    
  • 使用说明

    Lambda表达式被类方法替代的时候,它的形式参数全部传递给静态方法作为参数

3.4引用对象的实例方法【应用】

​ 引用对象的实例方法,其实就引用类中的成员方法

  • 格式

    对象::成员方法

  • 范例

    “HelloWorld”::toUpperCase

    String类中的方法:public String toUpperCase() 将此String所有字符转换为大写

  • 练习描述

    • 定义一个类(PrintString),里面定义一个方法

      public void printUpper(String s):把字符串参数变成大写的数据,然后在控制台输出

    • 定义一个接口(Printer),里面定义一个抽象方法

      void printUpperCase(String s)

    • 定义一个测试类(PrinterDemo),在测试类中提供两个方法

      • 一个方法是:usePrinter(Printer p)
      • 一个方法是主方法,在主方法中调用usePrinter方法
  • 代码演示

    public class PrintString {
        //把字符串参数变成大写的数据,然后在控制台输出
        public void printUpper(String s) {
            String result = s.toUpperCase();
            System.out.println(result);
        }
    }
    
    public interface Printer {
        void printUpperCase(String s);
    }
    
    public class PrinterDemo {
        public static void main(String[] args) {
    
    		//Lambda简化写法
            usePrinter(s -> System.out.println(s.toUpperCase()));
    
            //引用对象的实例方法
            PrintString ps = new PrintString();
            usePrinter(ps::printUpper);
    
        }
    
        private static void usePrinter(Printer p) {
            p.printUpperCase("HelloWorld");
        }
    }
    
    
  • 使用说明

    Lambda表达式被对象的实例方法替代的时候,它的形式参数全部传递给该方法作为参数

3.5引用类的实例方法【应用】

​ 引用类的实例方法,其实就是引用类中的成员方法

  • 格式

    类名::成员方法

  • 范例

    String::substring

    public String substring(int beginIndex,int endIndex)

    从beginIndex开始到endIndex结束,截取字符串。返回一个子串,子串的长度为endIndex-beginIndex

  • 练习描述

    • 定义一个接口(MyString),里面定义一个抽象方法:

      String mySubString(String s,int x,int y);

    • 定义一个测试类(MyStringDemo),在测试类中提供两个方法

      • 一个方法是:useMyString(MyString my)

      • 一个方法是主方法,在主方法中调用useMyString方法

  • 代码演示

    public interface MyString {
        String mySubString(String s,int x,int y);
    }
    
    public class MyStringDemo {
        public static void main(String[] args) {
    		//Lambda简化写法
            useMyString((s,x,y) -> s.substring(x,y));
    
            //引用类的实例方法
            useMyString(String::substring);
    
        }
    
        private static void useMyString(MyString my) {
            String s = my.mySubString("HelloWorld", 2, 5);
            System.out.println(s);
        }
    }
    
  • 使用说明

    ​ Lambda表达式被类的实例方法替代的时候
    ​ 第一个参数作为调用者
    ​ 后面的参数全部传递给该方法作为参数

3.6引用构造器【应用】

​ 引用构造器,其实就是引用构造方法

  • l格式

    类名::new

  • 范例

    Student::new

  • 练习描述

    • 定义一个类(Student),里面有两个成员变量(name,age)

      并提供无参构造方法和带参构造方法,以及成员变量对应的get和set方法

    • 定义一个接口(StudentBuilder),里面定义一个抽象方法

      Student build(String name,int age);

    • 定义一个测试类(StudentDemo),在测试类中提供两个方法

      • 一个方法是:useStudentBuilder(StudentBuilder s)

      • 一个方法是主方法,在主方法中调用useStudentBuilder方法

  • 代码演示

    public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    public interface StudentBuilder {
        Student build(String name,int age);
    }
    
    public class StudentDemo {
        public static void main(String[] args) {
    
    		//Lambda简化写法
            useStudentBuilder((name,age) -> new Student(name,age));
    
            //引用构造器
            useStudentBuilder(Student::new);
    
        }
    
        private static void useStudentBuilder(StudentBuilder sb) {
            Student s = sb.build("林青霞", 30);
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
    
  • 使用说明

    Lambda表达式被构造器替代的时候,它的形式参数全部传递给构造器作为参数

4.函数式接口

4.1函数式接口概述【理解】

  • 概念

    有且仅有一个抽象方法的接口

  • 如何检测一个接口是不是函数式接口

    @FunctionalInterface

    放在接口定义的上方:如果接口是函数式接口,编译通过;如果不是,编译失败

  • 注意事项

    我们自己定义函数式接口的时候,@FunctionalInterface是可选的,就算我不写这个注解,只要保证满足函数式接口定义的条件,也照样是函数式接口。但是,建议加上该注解

4.2函数式接口作为方法的参数【应用】

  • 需求描述

    定义一个类(RunnableDemo),在类中提供两个方法

    一个方法是:startThread(Runnable r) 方法参数Runnable是一个函数式接口

    一个方法是主方法,在主方法中调用startThread方法

  • 代码演示

    public class RunnableDemo {
        public static void main(String[] args) {
            //在主方法中调用startThread方法
    
            //匿名内部类的方式
            startThread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "线程启动了");
                }
            });
            
    		//Lambda方式
            startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
    
        }
    
        private static void startThread(Runnable r) {
            new Thread(r).start();
        }
    }
    

4.3函数式接口作为方法的返回值【应用】

  • 需求描述

    定义一个类(ComparatorDemo),在类中提供两个方法

    一个方法是:Comparator getComparator() 方法返回值Comparator是一个函数式接口

    一个方法是主方法,在主方法中调用getComparator方法

  • 代码演示

    public class ComparatorDemo {
        public static void main(String[] args) {
            //定义集合,存储字符串元素
            ArrayList<String> array = new ArrayList<String>();
    
            array.add("cccc");
            array.add("aa");
            array.add("b");
            array.add("ddd");
    
            System.out.println("排序前:" + array);
    
            Collections.sort(array, getComparator());
    
            System.out.println("排序后:" + array);
    
        }
    
        private static Comparator<String> getComparator() {
            //匿名内部类的方式实现
    //        return new Comparator<String>() {
    //            @Override
    //            public int compare(String s1, String s2) {
    //                return s1.length()-s2.length();
    //            }
    //        };
            
    		//Lambda方式实现
            return (s1, s2) -> s1.length() - s2.length();
        }
    }
    

4.4常用函数式接口之Supplier【应用】

  • Supplier接口

    Supplier接口也被称为生产型接口,如果我们指定了接口的泛型是什么类型,那么接口中的get方法就会生产什么类型的数据供我们使用。

  • 常用方法

    只有一个无参的方法

    方法名 说明
    T get() 按照某种实现逻辑(由Lambda表达式实现)返回一个数据
  • 代码演示

    public class SupplierDemo {
        public static void main(String[] args) {
    
            String s = getString(() -> "林青霞");
            System.out.println(s);
            
            Integer i = getInteger(() -> 30);
            System.out.println(i);
        }
    
        //定义一个方法,返回一个整数数据
        private static Integer getInteger(Supplier<Integer> sup) {
            return sup.get();
        }
    
        //定义一个方法,返回一个字符串数据
        private static String getString(Supplier<String> sup) {
            return sup.get();
        }
    
    }
    

4.5Supplier接口练习之获取最大值【应用】

  • 案例需求

    定义一个类(SupplierTest),在类中提供两个方法

    一个方法是:int getMax(Supplier sup) 用于返回一个int数组中的最大值

    一个方法是主方法,在主方法中调用getMax方法

  • 示例代码

    public class SupplierTest {
        public static void main(String[] args) {
            //定义一个int数组
            int[] arr = {19, 50, 28, 37, 46};
    
            int maxValue = getMax(()-> {
               int max = arr[0];
    
               for(int i=1; i<arr.length; i++) {
                   if(arr[i] > max) {
                       max = arr[i];
                   }
               }
    
               return max;
            });
    
            System.out.println(maxValue);
    
        }
    
        //返回一个int数组中的最大值
        private static int getMax(Supplier<Integer> sup) {
            return sup.get();
        }
    }
    

4.6常用函数式接口之Consumer【应用】

  • Consumer接口

    Consumer接口也被称为消费型接口,它消费的数据的数据类型由泛型指定

  • 常用方法

    Consumer:包含两个方法

    方法名 说明
    void accept(T t) 对给定的参数执行此操作
    default Consumer andThen(Consumer after) 返回一个组合的Consumer,依次执行此操作,然后执行 after操作
  • 代码演示

    public class ConsumerDemo {
        public static void main(String[] args) {
    		//操作一
            operatorString("林青霞", s -> System.out.println(s));
    		//操作二
            operatorString("林青霞", s -> System.out.println(new StringBuilder(s).reverse().toString()));
            
            System.out.println("--------");
    		//传入两个操作使用andThen完成
            operatorString("林青霞", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
        }
    
        //定义一个方法,用不同的方式消费同一个字符串数据两次
        private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
    //        con1.accept(name);
    //        con2.accept(name);
            con1.andThen(con2).accept(name);
        }
    
        //定义一个方法,消费一个字符串数据
        private static void operatorString(String name, Consumer<String> con) {
            con.accept(name);
        }
    }
    

4.7Consumer接口练习之按要求打印信息【应用】

  • 案例需求

    String[] strArray = {“林青霞,30”, “张曼玉,35”, “王祖贤,33”};

    字符串数组中有多条信息,请按照格式:“姓名:XX,年龄:XX"的格式将信息打印出来

    要求:

    把打印姓名的动作作为第一个Consumer接口的Lambda实例

    把打印年龄的动作作为第二个Consumer接口的Lambda实例

    将两个Consumer接口按照顺序组合到一起使用

  • 示例代码

    public class ConsumerTest {
        public static void main(String[] args) {
            String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
    
            printInfo(strArray, str -> System.out.print("姓名:" + str.split(",")[0]),
                    str -> System.out.println(",年龄:" + Integer.parseInt(str.split(",")[1])));
        }
    
        private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
            for (String str : strArray) {
                con1.andThen(con2).accept(str);
            }
        }
    }
    

4.8常用函数式接口之Predicate【应用】

  • Predicate接口

    Predicate接口通常用于判断参数是否满足指定的条件

  • 常用方法

    方法名 说明
    boolean test(T t) 对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
    default Predicate negate() 返回一个逻辑的否定,对应逻辑非
    default Predicate and(Predicate other) 返回一个组合判断,对应短路与
    default Predicate or(Predicate other) 返回一个组合判断,对应短路或
  • 代码演示

    public class PredicateDemo01 {
        public static void main(String[] args) {
            boolean b1 = checkString("hello", s -> s.length() > 8);
            System.out.println(b1);
    
            boolean b2 = checkString("helloworld",s -> s.length() > 8);
            System.out.println(b2);
    
        }
    
        //判断给定的字符串是否满足要求
        private static boolean checkString(String s, Predicate<String> pre) {
    //        return !pre.test(s);
            return pre.negate().test(s);
        }
    }
    
    public class PredicateDemo02 {
        public static void main(String[] args) {
            boolean b1 = checkString("hello", s -> s.length() > 8);
            System.out.println(b1);
            boolean b2 = checkString("helloworld", s -> s.length() > 8);
            System.out.println(b2);
    
            boolean b3 = checkString("hello",s -> s.length() > 8, s -> s.length() < 15);
            System.out.println(b3);
    
            boolean b4 = checkString("helloworld",s -> s.length() > 8, s -> s.length() < 15);
            System.out.println(b4);
        }
    
        //同一个字符串给出两个不同的判断条件,最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
        private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
            return pre1.or(pre2).test(s);
        }
    
        //判断给定的字符串是否满足要求
        private static boolean checkString(String s, Predicate<String> pre) {
            return pre.test(s);
        }
    }
    

4.9Predicate接口练习之筛选满足条件数据【应用】

  • 练习描述

    • String[] strArray = {“林青霞,30”, “柳岩,34”, “张曼玉,35”, “貂蝉,31”, “王祖贤,33”};

    • 字符串数组中有多条信息,请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中,并遍历ArrayList集合

    • 同时满足如下要求:姓名长度大于2;年龄大于33

  • 分析

    • 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断

    • 必须同时满足两个条件,所以可以使用and方法连接两个判断条件

  • 示例代码

    public class PredicateTest {
        public static void main(String[] args) {
            String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
    
            ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                    s -> Integer.parseInt(s.split(",")[1]) > 33);
    
            for (String str : array) {
                System.out.println(str);
            }
        }
    
        //通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
        private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
            //定义一个集合
            ArrayList<String> array = new ArrayList<String>();
    
            //遍历数组
            for (String str : strArray) {
                if (pre1.and(pre2).test(str)) {
                    array.add(str);
                }
            }
    
            return array;
        }
    }
    

4.10常用函数式接口之Function【应用】

  • Function接口

    Function<T,R>接口通常用于对参数进行处理,转换(处理逻辑由Lambda表达式实现),然后返回一个新的值

  • 常用方法

    方法名 说明
    R apply(T t) 将此函数应用于给定的参数
    default Function andThen(Function after) 返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
  • 代码演示

    public class FunctionDemo {
        public static void main(String[] args) {
    		//操作一
            convert("100",s -> Integer.parseInt(s));
    		//操作二
            convert(100,i -> String.valueOf(i + 566));
    		
            //使用andThen的方式连续执行两个操作
            convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
        }
    
        //定义一个方法,把一个字符串转换int类型,在控制台输出
        private static void convert(String s, Function<String,Integer> fun) {
    //        Integer i = fun.apply(s);
            int i = fun.apply(s);
            System.out.println(i);
        }
    
    
        //定义一个方法,把一个int类型的数据加上一个整数之后,转为字符串在控制台输出
        private static void convert(int i, Function<Integer,String> fun) {
            String s = fun.apply(i);
            System.out.println(s);
        }
    
    
        //定义一个方法,把一个字符串转换int类型,把int类型的数据加上一个整数之后,转为字符串在控制台输出
        private static void convert(String s, Function<String,Integer> fun1, Function<Integer,String> fun2) {
    
            String ss = fun1.andThen(fun2).apply(s);
            System.out.println(ss);
        }
    
    }
    

4.11Function接口练习之按照指定要求操作数据【应用】

  • 练习描述

    • String s = “林青霞,30”;

    • 请按照我指定的要求进行操作:

      1:将字符串截取得到数字年龄部分

      2:将上一步的年龄字符串转换成为int类型的数据

      3:将上一步的int数据加70,得到一个int结果,在控制台输出

    • 请通过Function接口来实现函数拼接

  • 示例代码

    public class FunctionTest {
        public static void main(String[] args) {
            String s = "林青霞,30";
            convert(s, ss -> ss.split(",")[1], Integer::parseInt, i -> i + 70);
        }
    
        private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
            int i = fun1.andThen(fun2).andThen(fun3).apply(s);
            System.out.println(i);
        }
    }
    

5.Strem流

5.1体验Stream流【理解】

  • 案例需求

    按照下面的要求完成集合的创建和遍历

    • 创建一个集合,存储多个字符串元素
    • 把集合中所有以"张"开头的元素存储到一个新的集合
    • 把"张"开头的集合中的长度为3的元素存储到一个新的集合
    • 遍历上一步得到的集合
  • 原始方式示例代码

    public class StreamDemo {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //把集合中所有以"张"开头的元素存储到一个新的集合
            ArrayList<String> zhangList = new ArrayList<String>();
    
            for(String s : list) {
                if(s.startsWith("张")) {
                    zhangList.add(s);
                }
            }
    
    //        System.out.println(zhangList);
    
            //把"张"开头的集合中的长度为3的元素存储到一个新的集合
            ArrayList<String> threeList = new ArrayList<String>();
    
            for(String s : zhangList) {
                if(s.length() == 3) {
                    threeList.add(s);
                }
            }
    
    //        System.out.println(threeList);
    
            //遍历上一步得到的集合
            for(String s : threeList) {
                System.out.println(s);
            }
            System.out.println("--------");
    
            //Stream流来改进
    //        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
            list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
        }
    }
    
  • 使用Stream流示例代码

    public class StreamDemo {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //Stream流来改进
            list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
        }
    }
    
  • Stream流的好处

    • 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义:获取流、过滤姓张、过滤长度为3、逐一打印

    • Stream流把真正的函数式编程风格引入到Java中

5.2Stream流的常见生成方式【应用】

  • Stream流的思想
    Stream流思想

  • 生成Stream流的方式

    • Collection体系集合

      使用默认方法stream()生成流, default Stream stream()

    • Map体系集合

      把Map转成Set集合,间接的生成流

    • 数组

      通过Stream接口的静态方法of(T… values)生成流

  • 代码演示

    public class StreamDemo {
        public static void main(String[] args) {
            //Collection体系的集合可以使用默认方法stream()生成流
            List<String> list = new ArrayList<String>();
            Stream<String> listStream = list.stream();
    
            Set<String> set = new HashSet<String>();
            Stream<String> setStream = set.stream();
    
            //Map体系的集合间接的生成流
            Map<String,Integer> map = new HashMap<String, Integer>();
            Stream<String> keyStream = map.keySet().stream();
            Stream<Integer> valueStream = map.values().stream();
            Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
    
            //数组可以通过Stream接口的静态方法of(T... values)生成流
            String[] strArray = {"hello","world","java"};
            Stream<String> strArrayStream = Stream.of(strArray);
            Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
            Stream<Integer> intStream = Stream.of(10, 20, 30);
        }
    }
    

5.3Stream流中间操作方法【应用】

  • 概念

    中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作。

  • 常见方法

    方法名 说明
    Stream filter(Predicate predicate) 用于对流中的数据进行过滤
    Stream limit(long maxSize) 返回此流中的元素组成的流,截取前指定参数个数的数据
    Stream skip(long n) 跳过指定参数个数的数据,返回由该流的剩余元素组成的流
    static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流
    Stream distinct() 返回由该流的不同元素(根据Object.equals(Object) )组成的流
    Stream sorted() 返回由此流的元素组成的流,根据自然顺序排序
    Stream sorted(Comparator comparator) 返回由该流的元素组成的流,根据提供的Comparator进行排序
    Stream map(Function mapper) 返回由给定函数应用于此流的元素的结果组成的流
    IntStream mapToInt(ToIntFunction mapper) 返回一个IntStream其中包含将给定函数应用于此流的元素的结果
  • filter代码演示

    public class StreamDemo01 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //需求1:把list集合中以张开头的元素在控制台输出
            list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
            System.out.println("--------");
    
            //需求2:把list集合中长度为3的元素在控制台输出
            list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
            System.out.println("--------");
    
            //需求3:把list集合中以张开头的,长度为3的元素在控制台输出
            list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
        }
    }
    
  • limit&skip代码演示

    public class StreamDemo02 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //需求1:取前3个数据在控制台输出
            list.stream().limit(3).forEach(System.out::println);
            System.out.println("--------");
    
            //需求2:跳过3个元素,把剩下的元素在控制台输出
            list.stream().skip(3).forEach(System.out::println);
            System.out.println("--------");
    
            //需求3:跳过2个元素,把剩下的元素中前2个在控制台输出
            list.stream().skip(2).limit(2).forEach(System.out::println);
        }
    }
    
  • concat&distinct代码演示

    public class StreamDemo03 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //需求1:取前4个数据组成一个流
            Stream<String> s1 = list.stream().limit(4);
    
            //需求2:跳过2个数据组成一个流
            Stream<String> s2 = list.stream().skip(2);
    
            //需求3:合并需求1和需求2得到的流,并把结果在控制台输出
    //        Stream.concat(s1,s2).forEach(System.out::println);
    
            //需求4:合并需求1和需求2得到的流,并把结果在控制台输出,要求字符串元素不能重复
            Stream.concat(s1,s2).distinct().forEach(System.out::println);
        }
    }
    
  • sorted代码演示

    public class StreamDemo04 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("linqingxia");
            list.add("zhangmanyu");
            list.add("wangzuxian");
            list.add("liuyan");
            list.add("zhangmin");
            list.add("zhangwuji");
    
            //需求1:按照字母顺序把数据在控制台输出
    //        list.stream().sorted().forEach(System.out::println);
    
            //需求2:按照字符串长度把数据在控制台输出
            list.stream().sorted((s1,s2) -> {
                int num = s1.length()-s2.length();
                int num2 = num==0?s1.compareTo(s2):num;
                return num2;
            }).forEach(System.out::println);
        }
    }
    
  • map&mapToInt代码演示

    public class StreamDemo05 {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("10");
            list.add("20");
            list.add("30");
            list.add("40");
            list.add("50");
    
            //需求:将集合中的字符串数据转换为整数之后在控制台输出
    //        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
    //        list.stream().map(Integer::parseInt).forEach(System.out::println);
    //        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
    
            //int sum() 返回此流中元素的总和
            int result = list.stream().mapToInt(Integer::parseInt).sum();
            System.out.println(result);
        }
    }
    

5.4Stream流终结操作方法【应用】

  • 概念

    终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作。

  • 常见方法

    方法名 说明
    void forEach(Consumer action) 对此流的每个元素执行操作
    long count() 返回此流中的元素数
  • 代码演示

    public class StreamDemo {
        public static void main(String[] args) {
            //创建一个集合,存储多个字符串元素
            ArrayList<String> list = new ArrayList<String>();
    
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
            list.add("张敏");
            list.add("张无忌");
    
            //需求1:把集合中的元素在控制台输出
    //        list.stream().forEach(System.out::println);
    
            //需求2:统计集合中有几个以张开头的元素,并把统计结果在控制台输出
            long count = list.stream().filter(s -> s.startsWith("张")).count();
            System.out.println(count);
        }
    }
    

5.5Stream流综合练习【应用】

  • 案例需求

    现在有两个ArrayList集合,分别存储6名男演员名称和6名女演员名称,要求完成如下的操作

    • 男演员只要名字为3个字的前三人

    • 女演员只要姓林的,并且不要第一个

    • 把过滤后的男演员姓名和女演员姓名合并到一起

    • 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据

    演员类Actor已经提供,里面有一个成员变量,一个带参构造方法,以及成员变量对应的get/set方法

  • 代码实现

    public class Actor {
        private String name;
    
        public Actor(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    
    public class StreamTest {
        public static void main(String[] args) {
            //创建集合
            ArrayList<String> manList = new ArrayList<String>();
            manList.add("周润发");
            manList.add("成龙");
            manList.add("刘德华");
            manList.add("吴京");
            manList.add("周星驰");
            manList.add("李连杰");
    
    
            ArrayList<String> womanList = new ArrayList<String>();
            womanList.add("林心如");
            womanList.add("张曼玉");
            womanList.add("林青霞");
            womanList.add("柳岩");
            womanList.add("林志玲");
            womanList.add("王祖贤");
    
            /*
            //男演员只要名字为3个字的前三人
            Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
    
            //女演员只要姓林的,并且不要第一个
            Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
    
            //把过滤后的男演员姓名和女演员姓名合并到一起
            Stream<String> stream = Stream.concat(manStream, womanStream);
    
            //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
    //        stream.map(Actor::new).forEach(System.out::println);
            stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
            */
    
            Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                    womanList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).
                    forEach(p -> System.out.println(p.getName()));
        }
    }
    

5.6Stream流的收集操作【应用】

  • 概念

    对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中。

  • 常用方法

    方法名 说明
    R collect(Collector collector) 把结果收集到集合中
  • 工具类Collectors提供了具体的收集方式

    方法名 说明
    public static Collector toList() 把元素收集到List集合中
    public static Collector toSet() 把元素收集到Set集合中
    public static Collector toMap(Function keyMapper,Function valueMapper) 把元素收集到Map集合中
  • 代码演示

    public class CollectDemo {
        public static void main(String[] args) {
            //创建List集合对象
            List<String> list = new ArrayList<String>();
            list.add("林青霞");
            list.add("张曼玉");
            list.add("王祖贤");
            list.add("柳岩");
    
            /*
            //需求1:得到名字为3个字的流
            Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
    
            //需求2:把使用Stream流操作完毕的数据收集到List集合中并遍历
            List<String> names = listStream.collect(Collectors.toList());
            for(String name : names) {
                System.out.println(name);
            }
            */
    
            //创建Set集合对象
            Set<Integer> set = new HashSet<Integer>();
            set.add(10);
            set.add(20);
            set.add(30);
            set.add(33);
            set.add(35);
    
            /*
            //需求3:得到年龄大于25的流
            Stream<Integer> setStream = set.stream().filter(age -> age > 25);
    
            //需求4:把使用Stream流操作完毕的数据收集到Set集合中并遍历
            Set<Integer> ages = setStream.collect(Collectors.toSet());
            for(Integer age : ages) {
                System.out.println(age);
            }
            */
            //定义一个字符串数组,每一个字符串数据由姓名数据和年龄数据组合而成
            String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};
    
            //需求5:得到字符串中年龄数据大于28的流
            Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);
    
            //需求6:把使用Stream流操作完毕的数据收集到Map集合中并遍历,字符串中的姓名作键,年龄作值
            Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));
    
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                Integer value = map.get(key);
                System.out.println(key + "," + value);
            }
        }
    }