1.定义
函数式接口就是java类型系统中的接口，只包含一个方法的特殊接口
使用语义化检测注解：@Functionallnterface
用户身份认证的接口
@FunctionalInterface
public interface UserIdentify {
/*
* 通过用户的账号，验证用户身份信息的接口
* @param username 验证的用户账号
* @return 返回用户身份信息【系统管理员，用户管理员，普通用户】
* */
String verifyUser(String username);
}1
2
3
4
5
6
7
8
9
10
消息传输格式化转换接口
@FunctionalInterface
public interface IMsgFormat {
/**
* 消息转换方法
* msg: 要转换的信息
* format：返回转换后的数据
*/
String format(String msg,String format);
}1
2
3
4
5
6
7
8
9
以上是对函数式接口的简单定义
分别实现上述的函数式接口
UserIdentifyImpl.java
public class UserIdentifyImpl implements UserIdentify {
//模拟实现业务逻辑
@Override
public String verifyUser(String username) {
if(“admin”.equals(username)){
return “系统管理员”;
}else if(“manager”.equals(username)){
return “用户管理员”;
}
return “普通会员”;
}
}1
2
3
4
5
6
7
8
9
10
11
12
IMsgFormatImpl
public class IMsgFormatImpl implements IMsgFormat {
@Override
public String format(String msg, String format) {
System.out.println(“消息转换…”);
return msg;
}
}1
2
3
4
5
6
7
在用户身份认证的接口添加如下默认的方法
//默认的方法
default String getIdentify(String username){
if(“admin”.equals(username)){
return “admin + 系统管理员用户”;
}else if(“manager”.equals(username)){
return “manager + 用户管理员用户”;
}else{
return “commons+普通用户”;
}
}1
2
3
4
5
6
7
8
9
10
在消息传输格式化转换接口添加如下静态的方法
/**
*
* @param msg 要验证的信息
* @return 返回验证的结果
*/
//静态方法
static boolean verifyMsg(String msg){
if(msg != null){
return true;
}
return false;
}1
2
3
4
5
6
7
8
9
10
11
12
进行测试
public static void main( String[] args )
{
//原始的方式
UserIdentify ui=new UserIdentifyImpl();
System.out.println(ui.verifyUser(“admin”));
System.out.println(ui.getIdentify(“admin”));
//静态方法
String msg=”hello”;
if(IMsgFormat.verifyMsg(msg)){
IMsgFormat format= new IMsgFormatImpl();
format.format(msg,”json”);
}
//匿名内部类实现接口的抽象方法
UserIdentify ui2=new UserIdentify() {
@Override
public String verifyUser(String username) {
return “admin”.equals(username)?”管理员”:”会员”;
}
};
System.out.println(ui2.verifyUser(“manager”));
System.out.println(ui2.verifyUser(“admin”));
//lambda表达式，针对函数式接口的简单实现
UserIdentify ui3=(String username) -> {
return “admin”.equals(username)?”lbd管理员”:”lbd会员”;
} ;
System.out.println(ui3.verifyUser(“manager”));
System.out.println(ui3.verifyUser(“admin”));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
运行结果展示
可见函数式接口可以添加默认的方法和静态的方法
Java类型系统内建函数式接口
java.util.funcation.Predicate
接受参数对象T，返回一个boolean类型的结果
Predicate pre=(String username) ->{
return “admin”.equals(username);
};
System.out.println(pre.test(“manager”));
System.out.println(pre.test(“admin”));1
2
3
4
5
java.util.funcation.Comsumer
接收参数对象T，不返回结果
Consumer con=(String message) -> {
System.out.println(“message:”+message);
System.out.println(“消息发送完成！”);
};
con.accept(“hello”);
con.accept(“hello lambda expression”);1
2
3
4
5
6
java.util.function.Function
接收参数对象T,返回结果对象R
Function fun=(String gender) -> {
return “male”.equals(gender)?1:0;
};
System.out.println(fun.apply(“male”));
System.out.println(fun.apply(“female”));1
2
3
4
5
java.util.function.Supplier
不接受参数，提供T对象的创建工厂
Supplier sup=() -> {
return UUID.randomUUID().toString();
};
System.out.println(sup.get());
System.out.println(sup.get());
System.out.println(sup.get());1
2
3
4
5
6
java.util.function.UnaryOperatorr
接口参数T对象，执行业务处理后，返回更新后的新的对象
UnaryOperator uo=(String img) -> {
img +=”[100*200]”;
return img;
};
System.out.println(uo.apply(“原图–“));1
2
3
4
5
java.util.function.BinaryOperator
接受两个T对象，返回一个T对象结果
BinaryOperator bo=(Integer i1,Integer i2) -> {
return i1 > i2 ? i1:i2;
};
System.out.println(bo.apply(12,15));1
2
3
4
总结
java.util.function提供了大量的函数式接口
Predicate 接受参数对象T，返回一个boolean类型的结果
Consumer 接收参数对象T,返回结果对象R
Function 接收参数T对象返回R对象
Supplier 不接受参数，提供T对象的创建工厂
UnaryOperator 接口参数T对象，执行业务处理后，返回更新后的新的对象
BinaryOperator 接受两个T对象，返回一个T对象结果