JAVA高级——lambda

- - 1、是什么是函数是接口？
  - 3、在哪里以及如何使用Lambda
- lambda实现：环绕执行模式
- - 2、使用函数时接口传递行为
  - 3、执行一个行为并转为lambda
- - 2、重构使用lambda的问题
  - - 2.1 重构lambda找不到情况
    - 2.2 从lambda表达式到方法引用的转换
  - 3、使用lambda重构设计模式

lambda基础

1、是什么是函数是接口？

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

:arrow_double_up: 上图就是一个函数是接口样式；

2、lambda的特点

匿名————没有明确的名称：写的少想的多（就是不直观）；
函数————它不像普通的方法有特定的类。但是方法一样，lambda有方法一切的特性；
传递————lambda表达式可以作为参数传递给方法或者存储在变量中；
简洁————无需使用匿名类，可以省掉很多模板；

下面是一个使用了lambda简化的代码模板：

public void test03(){
 
    // 原来
    Consumer consumer = new Consumer() {
 
        @Override
        public void accept(Person person) {
 
            System.out.println(person);
        }
    };
    // now 1
    Consumer consumer1 = person -> System.out.println(person);
    // now 2
    Consumer consumer2 = System.out::println;
    
}

3、在哪里以及如何使用Lambda

当接口是函数式接口时，可以使用；

lambda实现：环绕执行模式

这里我将述说如何自定义一个template去实现我们自己想要的函数格式；

代码样例：

// 这一行代码只能阅读固定的文件
    public String BufferReadProcessor1() throws IOException {
 
        try(BufferedReader br = new BufferedReader(new FileReader("data.txt"))){
 
            return br.readLine();
        }
    }

1、行为参数化

如果我一次性想读取多个行文件呢？

String result = processFile((BufferedReader br) -> br.readLine() + br.readLine());

2、使用函数时接口传递行为

package com.xiao.java_base.lambdas.demo01;

import java.io.BufferedReader;
import java.io.IOException;

@FunctionalInterface
public interface BufferReaderProcessor {
 
    String process(BufferedReader bufferedReader) throws IOException;
}

现在就可以把这个接口作为新的 ProcessFile 方法参数了

3、执行一个行为并转为lambda

@Test
public void test01() throws IOException {
 
   
    BufferReaderProcessor bufferReaderProcessor = new BufferReaderProcessor() {
 
        @Override
        public String process(BufferedReader bufferedReader) throws IOException {
 
            return bufferedReader.readLine() + bufferedReader.readLine();
        }
    };
   
    // 使用lambda进行优化
    BufferReaderProcessor bufferReaderProcessor = bufferedReader ->
            bufferedReader.readLine() + bufferedReader.readLine();
    // 执行process进行调用
    bufferReaderProcessor.process(new BufferedReader(new FileReader("data.txt")));
}

这里就说明了如果创建函数是接口、使用、合并的过程；

使用函数式接口

1、常用的函数型接口

Predicate:里面有一个 test() 方法，设置 Predicate函数接口的实现方法，通过传递参数，让其进行判断是否符合函数方法中的实现方法，如果符合就获取，否者就不进行操作；

public static  List filter(List list, Predicate p) {
 
    List results = new ArrayList<>();
    for (T t : list) {
 
        if (p.test(t)) {
 
            results.add(t);
        }
    }
    return results;
}

public static void main(String[] args) {
 
    Predicate nonEmptyStringPredicate = (String s) -> !s.isEmpty();
    List eeqwer = filter(Arrays.asList("args","123"), nonEmptyStringPredicate);
    System.out.println(eeqwer);
}

Function：创造型函数式接口

public class FunctionS {
 

    public static  List map(List list, Function f) {
 
        ArrayList result = new ArrayList<>();
        for (T t : list) {
 
            result.add(f.apply(t));
        }
        return result;
    }

    public static void main(String[] args) {
 
        List map = map(Arrays.asList("lambda", "in", "action"), String::length);
        // 传统写法
        //List map = map(Arrays.asList("lambda", "in", "action"), new Function() {
 
        //    @Override
        //    public Integer apply(String s) {
 
        //        return s.length();
        //    }
        //});
        System.out.println(map);
    }
}

Consume:消费型函数式接口，传入的数据源在接口中被消费，没有返回值；

public class ConsumeS {
 

    public static  void consumes(List list, Consumer consumer){
 
        for (T t : list) {
 
            consumer.accept(t);
        }
    }

    public static void main(String[] args) {
 
        consumes(Arrays.asList("args","123","eeeeer"),System.out::println);
    }
    /*
     运行结果：
            args
            123
            eeeeer
    */

}

注意：我们还需要考虑一个问题，就是基本数据类型的装箱和拆箱功能，这些会极大的影响 java的运行效率

所以java8 就自带了一个专门不用拆箱和装箱的类：

比如： IntPredicate 、 DoublePredicate 。。。

一般来说，针对专门的输入参数类型的函数式接口的名称都要加上对应的数据类型，那么就是可以免于上述性能问题；

这里是 int 数据类型 :arrow_double_down:

这里是 double 基本数据类型 :arrow_double_down:

2、重构使用lambda的问题

2.1 重构lambda找不到情况

接下来这个代码使用lambda的情况下都是可以成立，但是这个到底需要找那个呢？

public static void doSomething(Runnable runnable){
 
        runnable.run();
    }
    public static void doSomething(Task t){
 
        t.execute();
    }

    public static void main(String[] args) {
 
        // 这个没问题
        doSomething(new Task

JAVA高级——lambda