1.定义

函数式接口就是java类型系统中的接口，只包含一个方法的特殊接口
使用语义化检测注解：@Functionallnterface

用户身份认证的接口

@FunctionalInterface
public interface UserIdentify {
<span class="token comment">/*
* 通过用户的账号，验证用户身份信息的接口
* @param username 验证的用户账号
* @return 返回用户身份信息【系统管理员，用户管理员，普通用户】
* */</span>
String <span class="token function">verifyUser</span><span class="token punctuation">(</span>String username<span class="token punctuation">)</span><span class="token punctuation">;</span>

}
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<String> 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<String> 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>
接收参数对象T,返回结果对象R

 Function<String,Integer> 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<String> 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<String> 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<Integer> 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对象结果

IT夏天

Java8的函数式接口

1.定义

公告