java8 lambda表达式-内置四大函数式接口（Consumer、Supplier、Function、Predicate）-马育民老师

# 说明

我们想使用 **lambda表达式**，需要创建 **函数式接口**，频繁创建接口，繁琐，也造成接口太多

一般 **常用的** 函数式接口，就不需要创建了，直接使用这 **四大函数式接口** 即可

在 `java.util.function` 包内 , 有Java 内置核心四大函数式接口

# 应用场景

将 **不需改动** 的代码封装到方法中，方法有2个形参：

1. 数据
2. 核心算法

调用时，只需传入 **数据**、**核心算法** 即可

# Consumer 消费型接口

### 抽象方法

接收一个参数，对该 参数 进行处理，没有返回值

```
void accept(T t);
```

### 案例

定义一个 `handle` 方法，可以传入 **数据**、**Consumer**

```
public class ConsumerTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("李雷", "韩梅梅", "lucy", "lili");
        //lambda表达式写法
        handle(list, t -> System.out.println(t));
        //方法引用写法
        handle(list, System.out::println);
    }

public static void handle(List<String> list, Consumer<String> con){
        for ( String item : list) {
            con.accept(item);
        }
    }
}

```

# Supplier 供给型接口

### 抽象方法

没有形参，返回一个结果

```
T get();
```

不常使用

### 案例

```
public class SupplierTest {

public static void main(String[] args) {
        // lambda表达式写法
        randomList(10 , () -> Math.random() );
        // 方法引用写法
        randomList(10 , Math::random);
    }

public static List<Double> randomList(int num, Supplier<Double> sup){
        List<Double> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Double n = sup.get();
            list.add(n);
        }
        return list;
    }
}
```

# Predicate 断定型接口

### 抽象方法

接收一个参数，判断该 参数 是否满足条件，满足条件返回 `true`，否则返回 `false`

```
boolean test(T t);
```

### 例子

定义一个 `filter` 方法，传入 **数据**、**Predicate 判断条件**

```
public class PredicateTest {
    //将不需改动的代码封装到方法中，传入数据 和 核心算法
    public static List<String> filter(List<String> list, Predicate<String> pre){
        List<String> retList = new ArrayList<>();
        for (String str : list) {
            if(pre.test(str)){ //Predicate判断是否符合条件
                retList.add(str);
            }
        }
        return retList;
    }

public static void main(String[] args) {
        List<String> list = Arrays.asList("李雷", "韩梅梅", "lucy", "lili","李四");

List<String> resList = filter(list, (s) -> "李".equals(s.substring(0,1)));
        for (String item : resList) {
            System.out.println(item);
        }
    }
}

```

# Function 函数型接口

### 抽象方法

传入参数，返回一个结果

```
R apply(T t);
```

### 案例

```
public class FunctionTest {

public static void main(String[] args) {
        String[] array = new String[]{"90","80","85","92"};

//lamb表达式
        List list = handle(array,s -> Integer.parseInt(s));
        System.out.println(list);
        
        //方法引用
        List list2 = handle(array,Integer::parseInt);
        System.out.println(list2);

}
    public static List<Integer> handle(String[] array, Function<String,Integer> fun){
        List<Integer> retList = new ArrayList<>();
        for(String item : array){
            int i = fun.apply(item); // 调用 apply() 方法
            retList.add(i);
        }
        return retList;
    }
}
```

感谢：
https://www.cnblogs.com/myseries/p/13873788.html

原文出处：http://malaoshi.top/show_1IX36DpAWg8i.html