1
2
3
4
5
@FunctionalInterface
public interface Function<T, R> { 
    R apply(T t);
}

1
2
3
4
5
@FunctionalInterface
public interface Consumer<T> { 
    void accept(T t);
}

1
2
3
4
5
@FunctionnallInterface
public interface Supplier<T>{
	T get();
}

1
2
3
4
5
@FunctionalInterface
public interface Predicate<T> { 
    boolean test(T t);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class LambdaTest {


    public static void main(String[] args) {

//1.Runnale接口测试————run()
        Runnable r = () -> System.out.println("测试");
        r.run();


//2.Function接口测试————— T apply(X x)
        Function<Integer, Integer> fun = (age) -> {
            System.out.println("年龄为：" + age);//年龄为：21
            return age + 1;
        };
        System.out.println("下次过生日的年龄：" + fun.apply(21));//下次过生日的年龄：22

//3.Consumer接口测试————accept(T t)
        //3.1加泛型，推断s为String类型
        Consumer<String> con = (s) -> System.out.println(s + "666666");//双击关注666666
        con.accept("双击关注");
        //3.2不加泛型需要指定，默认为Object
        Consumer con2 = (s) -> System.out.println(s + "777777");//养猪厂子777777
        con2.accept("养猪厂子");

//4.Supplier接口测试
        //4.1不加泛型，则不推断
        Supplier sup = () -> {
            return new Integer(1);
        };
        //4.2加泛型，则可推断返回值为Integer
        Supplier<Integer> sup2 = () -> 1;

//5.Predicate接口测试
        Predicate<Integer> pred = (i) -> i > 10;
        System.out.println(pred.test(11));//ture
        System.out.println(pred.test(9));//false
    }
	}

1
2
3
4
5
@FunctionalInterface
public interface MyFunction<X,Y,Z,T> {
    T fun(X x,Y y ,Z z);
}

1
2
3
4
5
6
7
8
9
//6.自定义MyFunction接口
        MyFunction<Integer,Integer,Integer,String> myFun =
                (age,weight,higth) -> "年龄为：" + age
                                    + "体重为：" + weight
                                    + "身高为：" + higth;

        String myInfo = myFun.fun(21, 145, 181);
        System.out.println(myInfo);//年龄为：21体重为：145身高为：181

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class LambdaTest2 {
    public static void main(String[] args) {

        //0. People的非静态方法myHight()的形参 和 Function类的apply()方法的形参对应
        //                            的返回值 和                      的返回值对应

        People p = new People(21,"张家豪");
        //1.用 对象p :: 非静态方法
        Function<Integer,String> fun = p :: myHight;
        //2.此时的fun对象中的apply()方法已经和 p对象中的myHight()方法绑定
        System.out.println(fun.apply(181));


    }
}



class People{
    int age;
    String name;

    public  String myHight(Integer hight){
        return "my hight is " + hight;
    }}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
。。。。。。。。
    //编译看左：左边需要指定泛型，才能推断出右边的参数类型
        Consumer<Integer> con = People::describe;
        con.accept(2);
    }
}


class People {
    int age;
    String name;

    public static void describe2(Integer i) {
        System.out.println("People类有" + i + "个属性参数");
        System.out.println("一个是name，一个是age");
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
        Function<String,People> fun1 = s -> new People(s);
        People p1 = fun1.apply("张豪猪");
        
        Function<String,People> fun2 = People::new;
        People p2 = fun2.apply("豪猪张");

        BiFunction<Integer,String,People> bifun1 = People::new;
        People p3 = bifun1.apply(21, "豪张猪");


    }
}

@AllConstructor
class People {
    int age;
    String name;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    Function<Integer,People[]> fun1 = p -> new People[p];
    People[] arr1 = fun1.apply(10);//创建一个长度为10的People数组
    
    Function<Integer,People[]> fun2 = People[]::new;
    fun2.apply(20);

}
}


class People {
int age;
String name;