Java - 【JDK8】闭包

闭包（Closure）

• 存储没有返回值的函数
  • Consumer
  • BiConsumer<T,U>
• 存储有返回值的函数
  • Function<T,R>
  • BiFunction<T,U,R>
• 静态方法
  • 不需要指定第一个参数为类对象
• 非静态方法
  • 需要指定第一个参数为类对象
• 应用
  • forEach遍历List启动线程

---

一：概览

二：存储没有返回值的函数

import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 *  目的：测试JDK8提供的::语法与闭包
 *
 *  Consumer:
 *      1. 没有返回值的方法
 *      2. 只支持一个参数
 *          2.1 调用静态方法时，这个参数可以为方法实参
 *          2.2 调用非静态方法时，这个参数只能为包含该方法的类（意味着该非静态方法没有参数也没有返回值）
 *
 *  BiConsumer:
 *      1. 没有返回值的方法
 *      2. 支持两个参数
 *          2.1 调用静态方法时，这两个参数都可以为静态方法的实参
 *          2.2 调用非静态方法时，第一个参数只能够为包含该方法的类，第二个参数才可以使方法的实参（此时方法允许有一个参数）
 */
public class ConsumerTest {
    public static void main(String[] args) {
        Consumer<String> test1 = ConsumerTest::test1;
        test1.accept("xiaoming");    // test1: xiaoming

        BiConsumer<String,Integer> test2 = ConsumerTest::test2;
        test2.accept("xiaoming",18);    // test1: xiaoming: 18

        Consumer<ConsumerTest> test3 = ConsumerTest::test3;
        test3.accept(new ConsumerTest());    // test3

        BiConsumer<ConsumerTest,Integer> test4 = ConsumerTest::test4;
        test4.accept(new ConsumerTest(),999);    // test4: 999
    }


    private static void test1(String name){
        System.out.println("test1: "+name);
    }
    private static void test2(String name, int age){
        System.out.println("test1: "+name+": "+age);
    }

    private void test3(){
        System.out.println("test3");
    }

    private void test4(int data){
        System.out.println("test4: "+data);
    }
}

三：存储有返回值的函数

import java.util.function.BiFunction;
import java.util.function.Function;

/**
 * 目的：测试JDK8提供的::语法与闭包
 *
 * Function<T,R>:
 *      1. 有返回值的函数！
 *      2. 只支持一个参数
 *          2.1 调用静态方法时，这个参数可以为方法实参
 *          2.2 调用非静态方法时，这个参数只能为包含该方法的类（意味着该非静态方法没有参数）
 *
 * BiFunction<T,U，R>:
 *      1. 有返回值的函数！
 *      2. 支持两个参数
 *          2.1 调用静态方法时，两个参数均为方法实参
 *          2.2 调用非静态方法时，参数一必须为含有该方法的对象（意味着该方法只有一个参数）
 *
 */
public class FunctionTest {
    public static void main(String[] args) {
        Function<String,String> test1 = FunctionTest::test1;
        String test1Res = test1.apply("xiaoming");
        System.out.println(test1Res);    // test1: xiaoming

        BiFunction<String, Integer, String> test2 = FunctionTest::test2;
        String test2Res = test2.apply("xiaoming",18);
        System.out.println(test2Res);    // test2: xiaoming:18

        Function<FunctionTest, String> test3 = FunctionTest::test3;
        String test3Res = test3.apply(new FunctionTest());
        System.out.println(test3Res);    // test3

        BiFunction<FunctionTest, String, String> test4 = FunctionTest::test4;
        String test4Res = test4.apply(new FunctionTest(),"xiaoming");
        System.out.println(test4Res);    // test4: xiaoming

    }

    private static String test1(String name){
        return "test1: "+name;
    }
    private static String test2(String name, int age){
        return "test2: "+name+":"+age;
    }

    private String test3(){
        return "test3";
    }
    private String test4(String name){
        return "test4: "+name;
    }
}

四：应用

1> forEach遍历List运行线程（forEach的参数为闭包）

import java.util.ArrayList;
import java.util.List;

/**
 * 测试forEach的使用
 *
 * 创建100个线程，使用List存储，使用forEach运行线程
 *
 * 1. 线程执行完了再调用join会有什么现象？
 *      什么现象也没有。
 */
public class Test {
    public static void main(String[] args) {
        List<Thread> list = new ArrayList<>();

        for(int i=0;i<100;i++){
            list.add(new Thread(()->{
                System.out.println("hello");
            },"thread-"+i));
        }

        list.forEach(Thread::start);

        list.forEach(t->{
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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