前言

function是java8的特性,之前零零散散接触过,但是都没怎么深入研究过这块,先来个扫盲篇,后续再好好整理。

实战

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package functiondemo;

import java.util.function.*;

/**
* @author jianweilin
* @date 2018/8/13
*/
public class FunctionDemo {
/**
* BiConsumer<T,U>
* T、U 均为入参,无返回值
*/
public static void biConsumer() {
BiConsumer<String, String> consumer = (x, y) -> {
System.out.println(String.format("x = %s,y=%s", x, y));
};
consumer.accept("test01", "test02");
}

/**
* BiFunction<T,U,R>
* T,U 为入参,R为返回值
*/
public static void biFunction() {
BiFunction<String, String, String> bi = (x, y) -> {
return x + y;
};

System.out.println(bi.apply("jian", ".com"));
}

/**
* BiPredicate<T,U>
* T,U 为入参,Boolean会返回值
*/
public static void biPredicate() {
BiPredicate<Integer, Integer> bi = (x, y) -> x > y;
BiPredicate<Integer, Integer> eq = (x, y) -> x - 2 > y;

System.out.println(bi.test(2, 3));
System.out.println(bi.and(eq).test(2, 3));
}

/**
* BinaryOperator<T>
* 两个入参,得到一个返回值
*/
public static void binaryOperator() {
BinaryOperator<Integer> operator = (n1, n2) -> n1 + n2;
System.out.println(operator.apply(3,4));
}

/**
* 返回一个boolean类型
*/
public static void booleanSupplier(){
BooleanSupplier bs = () -> true;
System.out.println(bs.getAsBoolean());
}

/**
* 一个函数接受一个入参,无返回值
*/
public static void consumer(){
Consumer<String> c = (x) -> System.out.println(x.toUpperCase());
c.accept("hello world!");
}

/**
* Function<T,R>
* 接受一个参数,并得到一个返回结果
*/
public static void function(){
Function<Integer,String> converter = (i) -> Integer.toString(i);
System.out.println(converter.apply(3).length());
System.out.println(converter.apply(30).length());
}

public static void main(String[] args) {
function();
}
}

参考资料

  1. Oracle Function文档
  2. Function实战