javaSE------8.函数

最新推荐文章于 2024-06-24 09:00:00 发布

放线机器人

最新推荐文章于 2024-06-24 09:00:00 发布

阅读量332

点赞数

文章标签： java

本文链接：https://blog.csdn.net/L15122698902/article/details/115589705

版权

1. Lambda表达式

1.1 体验Lambda表达式

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

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

/*
案例需求
        启动一个线程，在控制台输出一句话：多线程程序启动了
*/
public class myLambda {
    public static void main(String[] args) {
       /* 实现方式一：
        1.定义一个类MyRunnable实现Runnable接口，重写run()方法
        2.创建MyRunnable类的对象
        3.创建Thread类的对象，把MyRunnable的对象作为构造参数传递
        4.启动线
        */
       //创建MyRunnable对象
        MyRunnable mr = new MyRunnable();

        //创建多线程对象，把Runnable的实现类对象mr传进去，并启动线程
        new Thread(mr).start();


        //实现方式二：
        //匿名内部类的方式改进
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了");
            }
        }).start();


        //实现方式三：
        //Lambda表达式的方式改进
        new Thread(()->{
            System.out.println("多线程程序启动了");
        }).start();
    }
}

Runnable的实现类对象：
public class MyRunnable implements Runnable{//继承Runnable接口
    //重写run方法
    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}

1.2 Lambda表达式的标准格式

格式：

	(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

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

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

组成Lambda表达式的三要素：形式参数，箭头，代码块

1.3 Lambda表达式练习1

Lambda表达式的使用前提
（1）有一个接口

（2）接口中有且仅有一个抽象方法

练习描述：
无参无返回值抽象方法的练习

操作步骤：
（1）定义一个接口(Eatable)，里面定义一个抽象方法：void eat();

（2）定义一个测试类(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()的参数里
        EatableImpl eai = new EatableImpl();
        useEatable(eai);

        //方式二：匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("吃苹果了！");
            }
        });


        //方式三：Lambda表达式
        useEatable(()->{
            System.out.println("吃苹果了！");
        } );
    }


    private static void useEatable(Eatable e) {
        e.eat();
    }
}

1.4 Lambda表达式练习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(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("一个筋斗十万八千里");
        });
    }

1.5 Lambda表达式练习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(new Addable() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });

        System.out.println("--------");

        //Lambda表达式：
        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.6 Lambda表达式的省略模式

省略的规则：
参数类型可以省略。但是有多个参数的情况下，不能只省略一个

如果参数有且仅有一个，那么小括号可以省略

如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

接口1：
public interface Flyable {
    void fly(String s);
}

接口2：
public interface Addable {
    int add(int x,int y);
}

测试类：
public class LambdaDemo {
    public static void main(String[] args) {
//参数类型可以省略，只有一条语句时省略大括号和语句后面的分号,如果有return，return也要省略掉
        //如果参数有且仅有一个，那么小括号可以省略
        useFlyable((s ->System.out.println(s)));

        System.out.println("---------");

        useAddable((x,y)->x+y);
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println("两数之和为："+sum);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

1.7 Lambda表达式的注意事项

（1）使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法

（2）必须有上下文环境，才能推导出Lambda对应的接口

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

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

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

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

1.8 Lambda表达式和匿名内部类的区别

所需类型不同：

匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

Lambda表达式：只能是接口

使用限制不同：
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

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

实现原理不同：
匿名内部类：编译之后，产生一个单独的.class字节码文件

Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

2. 接口组成更新

2.1 接口组成更新概述

（1）常量：public static final

（2）抽象方法：public abstract

（3）默认方法(Java 8)

（4）静态方法(Java 8)

（5）私有方法(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() { }

注意事项：
默认方法可以调用私有的静态方法和非静态方法

静态方法只能调用私有的静态方法

接口：
public interface myInterface {
    
    //默认方法:   可以调用私有的静态方法和非静态方法
         default void show1(){
        System.out.println("show1();开始");
//        System.out.println("java初级工程师");
//        System.out.println("java中级工程师");
//        System.out.println("java高级工程师");
          pri1();//私有非静态方法
        System.out.println("show1();结束");
        System.out.println("--------");
    }

        default void show2(){
        System.out.println("show2();开始");
//        System.out.println("java初级工程师");
//        System.out.println("java中级工程师");
//        System.out.println("java高级工程师");
          pri2();     //私有静态方法
        System.out.println("show2();结束");
            System.out.println("--------");
    }

    //静态方法：  只能调用私有的静态方法
        static void method1(){
        System.out.println("method1();开始");
//        System.out.println("java初级工程师");
//        System.out.println("java中级工程师");
//        System.out.println("java高级工程师");
            pri2();   //私有静态方法
        System.out.println("method1();结束");
            System.out.println("--------");
    }

        static void method2(){
        System.out.println("method2();开始");
//        System.out.println("java初级工程师");
//        System.out.println("java中级工程师");
//        System.out.println("java高级工程师");
            //pri1();   //私有静态方法
        System.out.println("method2();结束");
    }

    //私有方法(非静态)
    private void pri1(){
        System.out.println("java初级工程师");
        System.out.println("java中级工程师");
        System.out.println("java高级工程师");
    }

    //私有方法(静态)
    private static void pri2(){
        System.out.println("java初级工程师");
        System.out.println("java中级工程师");
        System.out.println("java高级工程师");
    }
}

接口实例化对象：
public class myInterfaceImpl implements myInterface{
    //此处不用重写方法
}

测试类：
public class myInterfaceDemo {
    public static void main(String[] args) {
        //多态的形式创建对象
        myInterface my=new myInterfaceImpl();

        my.show1();
        my.show2();

        //静态方法直接用，接口名调用
        myInterface.method1();
    }
}

3. 方法引用

3.1 体验方法引用

方法引用的出现原因：
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

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

那我们又是如何使用已经存在的方案的呢？
这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案

接口：
public interface Printable {
    void printString(String s);
}

测试类：
public class PrintableDemo {
    public static void main(String[] args) {
        //Lambda表达式(简化)
        usePrintable(s -> System.out.println(s));

        System.out.println("--------");

        //方法引用
        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类型数据

使用说明：
Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

练习描述：
定义一个接口(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));

        System.out.println("--------");

        //引用类方法:
        //Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
        useConverter(Integer::parseInt);
    }

    private static void useConverter(Converter c) {
        System.out.println(c.convert("666"));
    }
}

3.4 引用对象的实例方法

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

格式：
	对象::成员方法
范例：
	"HelloWorld"::toUpperCase
	String类中的方法：public String toUpperCase() 将此String所有字符转换为大写

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

练习描述：
定义一个类(PrintString)，里面定义一个方法public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出

定义一个接口(Printer)，里面定义一个抽象方法void printUpperCase(String s)

定义一个测试类(PrinterDemo)，在测试类中提供两个方法
一个方法是：usePrinter(Printer p)
一个方法是主方法，在主方法中调用usePrinter方法

接口：
public interface Printer {
    void printUpperCase(String s);
}

具体类：
public class PrintString {

//定义一个方法public void printUpper(String s)：把字符串参数变成大写的数据，然后在控制台输出
    public void printUpper(String s){

        System.out.println(s.toUpperCase());
    }
}

测试类：
public class PrinterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        usePrinter(s -> System.out.println(s.toUpperCase()));

        System.out.println("--------");

        //引用对象的实例方法
        //Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
        //创建对象
        PrintString ps=new PrintString();
        usePrinter(ps::printUpper);
    }

    private static void usePrinter(Printer p) {
        p.printUpperCase("helloworld");
    }
}

3.5 引用类的实例方法

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

格式：
	类名::成员方法
范例：
	String::substring
	public String substring(int beginIndex,int endIndex)
	从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex

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

练习描述：
定义一个接口(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)));

        //引用类的实例方法：Lambda表达式被类的实例方法替代的时候 第一个参数作为调用者 后面的参数全部传递给该方法作为参数
        useMyString(String::substring);
    }

    private static void useMyString(MyString my) {
        System.out.println(my.mySubString("HelloWorld",2,5));
    }
}

3.6 引用构造器

引用构造器，其实就是引用构造方法

格式
	类名::new
范例
	Student::new

使用说明：
Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数

练习描述：
定义一个类(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)));

        System.out.println("--------");

        //引用构造器
        useStudentBuilder(Student::new);
    }

    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("令狐冲", 25);
        System.out.println(s.getName()+s.getAge());
    }
}

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() + "：线程启动了");
            }
        });

        System.out.println("--------");

        //方式二：Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "：线程启动了"));
    }


    public static void startThread(Runnable r) {
        new Thread(r).start();
    }
}

4.3 函数式接口作为方法的返回值

/*需求描述
        定义一个类(ComparatorDemo)，在类中提供两个方法
        一个方法是：Comparator getComparator() 方法返回值Comparator是一个函数式接口
        一个方法是主方法，在主方法中调用getComparator方法*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> arr=new ArrayList<>();
        //添加元素
        arr.add("aa");
        arr.add("ssss");
        arr.add("ddd");
        arr.add("cccccc");

        System.out.println("排序前："+arr);

       // static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。
        Collections.sort(arr,getComparator());

        System.out.println("排序后："+arr);
    }

    public 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表达式实现)返回一个数据

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        Integer i = getInteger(() -> 10086);
        System.out.println(i);

        String s = getString(() -> "令狐冲");
        System.out.println(s);
    }

    //定义一个方法，返回一个整数数据
    public static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }

    //定义一个方法，返回一个字符串数据
    public static String getString(Supplier<String> sup){
        return sup.get();
    }
}

4.5 Supplier接口练习之获取最大值

/*案例需求
        定义一个类(SupplierTest)，在类中提供两个方法
        一个方法是：int getMax(Supplier sup) 用于返回一个int数组中的最大值
        一个方法是主方法，在主方法中调用getMax方法*/
import java.util.function.Supplier;
public class SupplierDemo02 {
    public static void main(String[] args) {
        //定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};


        int maxNumber = getMax(() -> {
            int max = arr[0];

            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });

        System.out.println(maxNumber);
    }

    public 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操作

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {

        //操作一：控制台输出字符串
        operatorString("令狐冲",s -> System.out.println(s));
        //操作二：将字符串转为StringBuilder，反转后转化为String
        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()));
    }

    //定义一个方法，消费一个字符串数据
    public static void operatorString(String name,Consumer<String> con){
            con.accept(name);
    }

    //定义一个方法，用不同的方式消费同一个字符串数据两次
    public static void operatorString(String name,Consumer<String> con1,Consumer<String> con2){
//            con1.accept(name);
//            con2.accept(name);
              con1.andThen(con2).accept(name);
    }
}

4.7 Consumer接口练习之按要求打印信息

/*案例需求
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
        字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来

        要求：
        把打印姓名的动作作为第一个Consumer接口的Lambda实例
        把打印年龄的动作作为第二个Consumer接口的Lambda实例
        将两个Consumer接口按照顺序组合到一起使用*/
import java.util.function.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]))
        );

    }

    //定义一个方法，完成两个操作
    public 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) 返回一个组合判断，对应短路或

test01:
import java.util.function.Predicate;

public class PredicateDemo {
    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);
        
    }
    
    //判断给定的字符串是否满足要求
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }
}

test02:
import java.util.function.Predicate;

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

        System.out.println("--------");

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

    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2 ){
        //return pre1.and(pre2).test(s);
        return pre1.or(pre2).test(s);

    }

    //判断给定的字符串是否满足要求
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.negate().test(s);
    }
}

4.9 Predicate接口练习之筛选满足条件数据

/*练习描述
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
        字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并
        遍历ArrayList集合
        同时满足如下要求：姓名长度大于2；年龄大于33

        分析
        有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
        必须同时满足两个条件,所以可以使用and方法连接两个判断条件*/
import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};

        ArrayList<String> arr = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33
        );
        
        //遍历ArrayList集合
        for (String ss:arr) {
            System.out.println(ss);
        }
    }

private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1,Predicate<String> pre2) {
        ArrayList<String> arrayList=new ArrayList<>();

        for (String str:strArray) {
            if (pre1.and(pre2).test(str)) {
                arrayList.add(str);
            }
        }
        return arrayList;
    }
}

4.10 常用函数式接口之Function

Function接口:

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

常用方法:

R apply(T t) 将此函数应用于给定的参数

default Function andThen(Function after)  返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

示例：
import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        //操作一：
        convert("100",s -> Integer.parseInt(s));

        //操作二：
        convert(100,i->String.valueOf(100+566));

        //使用andThen的方式连续执行两个操作
        convert("100",s -> Integer.parseInt(s),i ->String.valueOf(i+566) );
        
    }
    //定义一个方法，把一个字符串转换int类型，在控制台输出
    public static  void convert(String s, Function<String,Integer> fun){
        Integer i = fun.apply(s);
        System.out.println(i);
    }

    //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
    public static  void convert(Integer i, Function<Integer,String> fun){
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台 输出
    public 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.11 Function接口练习之按照指定要求操作数据

/*练习描述
        String s = "林青霞,30";
        请按照我指定的要求进行操作：
        1:将字符串截取得到数字年龄部分
        2:将上一步的年龄字符串转换成为int类型的数据
        3:将上一步的int数据加70，得到一个int结果，在控制台输出
        请通过Function接口来实现函数拼接*/
import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";
        convert(s,ss->s.split(",")[1],ss->Integer.parseInt(ss),ss->String.valueOf(ss+70));
    }

    private static void convert(String s, Function<String,String> fun1, Function<String,Integer> fun2,Function<Integer,String> fun3) {
        String ss = fun1.andThen(fun2).andThen(fun3).apply(s);

        System.out.println(ss);
    }
}

5. Strem流

5.1 体验Stream流

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

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

/*案例需求
        按照下面的要求完成集合的创建和遍历
        创建一个集合，存储多个字符串元素
        把集合中所有以"张"开头的元素存储到一个新的集合
        把"张"开头的集合中的长度为3的元素存储到一个新的集合
        遍历上一步得到的集合*/

import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
        //1.创建一个集合，存储多个字符串元素
        ArrayList<String> arrayList=new ArrayList<>();

        arrayList.add("小龙女");
        arrayList.add("张无忌");
        arrayList.add("任盈盈");
        arrayList.add("张三丰");
        arrayList.add("张敏");
        arrayList.add("令狐冲");

        //2.把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> zhangList=new ArrayList<>();
        for (String s:arrayList) {
            if (s.startsWith("张")) {
                zhangList.add(s);
            }
        }

        //3.把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList=new ArrayList<>();
        for (String s:zhangList) {
            if (s.length()==3) {
                threeList.add(s);
            }
        }

        //4.遍历上一步得到的集合
        for (String s:threeList) {
            System.out.println(s);
        }

        System.out.println("--------");

        //Stream流改进
        arrayList.stream().filter(s->s.startsWith("张")).filter(s -> s.length()==3).forEach(System.out::println);
    }
}

5.2 Stream流的常见生成方式

Stream流的思想：
在这里插入图片描述
生成Stream流的方式：

（1）Collection体系集合
使用默认方法stream()生成流， default Stream stream()

（2）Map体系集合
把Map转成Set集合，间接的生成流

（3）数组
通过Stream接口的静态方法of(T… values)生成流

示例：
import java.util.*;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        //1.Collection体系的集合可以使用默认方法stream()生成流
        List<String> list=new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set=new HashSet<>();
        Stream<String> setStream = set.stream();

        //2.Map体系的集合间接的生成流
        Map<String,String> map=new HashMap<>();

        //Set<String> set1 = map.keySet();           可以看出键的集合是Set类型的
        Stream<String> ketStream = map.keySet().stream();

        //Collection<String> values = map.values();    可以看出值的集合是Collection类型的
        Stream<String> valueStream = map.values().stream();

        //3.数组可以通过Stream接口的静态方法of(T... values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> array = Stream.of(strArray);

        //也可以：
        Stream<String> stringStream = Stream.of("hello", "world", "java");
        Stream<Integer> integerStream = Stream.of(10, 20, 30, 40);
    }
}

5.3 Stream流中间操作方法

概念：
中间操作的意思是，执行完此方法之后，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其中包含将给定函数应用于此流的元素的结果

（1）filter代码演示：

import java.util.ArrayList;

public class FilterDemo {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();

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

（2）limit&skip代码演示：

import java.util.ArrayList;

public class StreamDemo02 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();

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

（3）concat&distinct代码演示：

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamDemo03 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();

        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);  //concat是静态方法，通过类名调用

        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

（4）sorted代码演示：

import java.util.ArrayList;

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

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

（5）map&mapToInt代码演示：

import java.util.ArrayList;

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.add("60");

        //需求：将集合中的字符串数据转换为整数之后在控制台输出
        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        //list.stream().map(Integer::parseInt).forEach(System.out::println);

        list.stream().mapToInt(s->Integer.parseInt(s)).forEach(System.out::println);

        //int sum() 返回此流中元素的总和，mapToInt的特有方法
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

5.4 Stream流终结操作方法

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

常见方法：

void forEach(Consumer action)   对此流的每个元素执行操作

long count()   返回此流中的元素数

示例：
import java.util.ArrayList;

public class StreamDemo06 {
    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);
        System.out.println("--------");

        //需求2：统计集合中有几个以张开头的元素，并把统计结果在控制台输出
        long counts = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(counts);
    }
}

5.5 Stream流综合练习

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

男演员只要名字为3个字的前三人
女演员只要姓林的，并且不要第一个
把过滤后的男演员姓名和女演员姓名合并到一起
把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

演员类：
public class Actors {
    private String name;

    public Actors() {
    }

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

    public String getName() {
        return name;
    }

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

import java.util.ArrayList;
import java.util.stream.Stream;

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> man = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演员只要姓林的，并且不要第一个
        Stream<String> woman = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(man, woman);

        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
        stream.map(Actors::new).forEach(p->System.out.println(p.getName()));
        */
        
        //改进：
        Stream.concat(manList.stream().filter(s -> s.length()==3),
                        womanList.stream().filter(s -> s.startsWith("林")).skip(1)).
                        map(Actors::new).forEach(p-> System.out.println(p.getName()));
    }
}

5.6 Stream流的收集操作

概念：
对数据使用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集合中

示例：
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectDemo {
    public static void main(String[] args) {
        /*-------List
        //创建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集合对象
        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(s -> s > 25);

        //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age:ages) {
            System.out.println(age);
        }
        */

        //-------Map
        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        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);
        }
    }
}