java8 函数式接口_Java8的函数式接口

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对象结果