函数式接口与lambda表达式

函数式接口与lambda表达式

什么是函数式接口？

是lambda表达式的类型

public void forEach(Consumer<? super T> consumer);

其中的consumer实例可以被lambda表达式替代，这就表示每个函数式接口中只能有一个抽象方法，才不会造成歧义

lambda表达式是什么？

lambda表达式是函数式接口的一个实例，是一种简化的写法

以下面为例，首先定义一个简单的接口

interface IntOperation{int operate(int i);}

然后采用传统的方法对其进行实例化，可以看出构造了一个匿名内部类，重写了operate方法

IntOperation normal = new IntOperation() {
            @Override
            public int operate(int i) {
                return i*2;
            }
        };

可以使用lambda接口替代这个匿名内部类

IntOperation iop = i -> i * 2;

其中,“->”前面的i就是方法的参数，“->”后面就是方法体

lambda表达式的作用？

1 优化集合的输出

传统的list遍历打印需要

List<String> lists = new ArrayList<>(); 
for(String str:lists) {sout(str);}

使用lambda表达式可以简化为

lists.forEach((str) -> sout(str));

事实上还可以简化成函数引用

lists.forEach(System.out::println);

2 用于替代匿名内部类

在多线程中很常用
下面是传统的多线程创建方式

for(int i=0;i<10;i++){
           new Thread(new Runnable() {
               @Override
               public void run() {
                   System.out.println(Thread.currentThread().getId());
               }
           }).start();
       }

其中Runnable是典型的匿名内部类，也是一个典型的函数式接口，因此可以用lambda表达式进行替换

for(int i=0;i<10;i++){
           new Thread(() -> System.out.println(Thread.currentThread().getId())).start();
       }

替换后变得很简洁

3 作为函数式接口的实例

java.util.function为我们提供了标准的函数式接口
四大核心

其他的一些

假如我们现在需要实现一个功能，使list1中的所有数字加1后存入list2，就可以调用Function<T,R>接口实现

public List<Integer> fun(List<Integer> list, Function<Integer,Integer> function){
        List<Integer> tempList = new ArrayList<>();
        for(Integer integer:list) tempList.add(function.apply(integer));
        return tempList;
    }
    @Test
    public void test() {
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        List<Integer> list2 = fun(list1,(a) -> a+1);
        list2.forEach(System.out::println);
    }

4 和Optional<T>配合使用进行null检测

Optional<T>是JAVA8的新特性，可以进行null值检测

Optional<T>例子如下

Integer a = null;
Integer b = 10;
//使用ofNullable对 对象 进行封装
Optional<Integer> opa = Optional.ofNullable(a);
Optional<Integer> opb = Optional.ofNullable(b);

//orElse判断对象是否存在，不存在的话直接赋设定值
Integer c = opa.orElse(0) + opb.orElse(0);
System.out.println(c);

针对常用的null处理，可使用lambda进行改造
首先对Integer类对象进行一层Optional的包装

Integer i = null;
        Optional<Integer> opi = Optional.ofNullable(i);

情况1：对象不为null就输出

//情况1 如果不为null就执行
    if(i!=null){
        System.out.println(i);
    }
    //可以转换为lambda表达式
    opi.ifPresent(System.out::println);

情况2：存在则返回，不存在则返回特定值

//情况2 存在则返回，不存在则返回0
    if(i!=null){
        return i;
    }else{
        return 0;
    }
    //可以转换成lambda表达式
    return opi.orElse(0);

情况3：存在则返回，不存在则调用其他方法

    //情况3：存在则返回，不存在则调用其他方法
    if(i!=null){
        return i;
    }else{
        otherFun();
    }
    //可以使用lambda表达式替换
    return opi.orElseGet(()->otherFun());

更多optional<T>的用法见
optional