JUC学习笔记-10-四大函数式接口和Stream流式计算

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口：只有一个方法的接口

10.1 四大函数式接口

10.1.1 Function函数型接口

需传入的泛型类型

• 第一个泛型是输入值的类型
• 第二个泛型是返回值的类型
  

import java.util.function.Function;
//四大函数式接口之函数型接口
public class FunctionDemo {
    public static void main(String[] args) {
        //第一个泛型是传入参数类型，第二个泛型返回参数类型
        Function<String, String> function = (str) -> {return str;};
        System.out.println(function.apply("aaaaaaaaaa"));
    }
}

10.1.2 Predicate断定型接口

断定型顾名思义判断输入是否符合预期，故需传入参数
需传入的泛型类型

• 有且仅有一个泛型是输入值的类型
  

//四大函数式接口之断定型接口，判断返回boolean值
public class PredicateDemo {
    public static void main(String[] args) {
        //传入的泛型是输入值的类型，返回boolean
        Predicate<String> predicate = (str) -> {return str.isEmpty();};
        // false
        System.out.println(predicate.test("aaa"));
        // true
        System.out.println(predicate.test(""));
    }
}

10.1.3 Supplier供给型接口

供给型顾名思义能够获得什么，所以不需要传入参数，直接获得返回值
需传入的泛型类型

• 有且仅有一个泛型是返回值的类型
  

//供给型接口，只返回，不输入
public class SupplierDemo {
    public static void main(String[] args) {
        //传入的泛型是返回值的类型
        Supplier<String> supplier = ()->{return "1024";};
        System.out.println(supplier.get());
    }
}

10.1.4 Consumer消费性接口

消费性顾名思义便是消费，消费便要钱，所以需要传入输入值的类型
需传入的泛型类型

• 有且仅有一个泛型是输入值的类型
  

//消费型接口 没有返回值！只有输入！
public class ConsumerDemo {
    public static void main(String[] args) {
        //传入的泛型类型是输入值的参数类型
        Consumer<String> consumer = (str)->{ System.out.println(str); };
        consumer.accept("abc");
    }
}

10.2 Stream流式计算

10.2.1 Stream流的认识

大数据时代 = 存储 + 计算
存储的操作交给集合、数据库来完成
而计算的操作交给流来完成，所以流就是用来实现计算的
流的出现便是让集合操作变得更加简介，通常我们需要多行才能完成的操作，借助于流式处理可以在一行中实现。比如帅选出集合中所有的偶数
集合操作

List<Integer> evens = new ArrayList<>();
for (final Integer num : nums) {
    if (num % 2 == 0) {
        evens.add(num);
    }
}

通过流操作

List<Integer> evens = nums.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());

可以看出，通过流我们一行代码便可实现的功能，让代码变得更加简洁

10.2.2 Stream流的处理阶段

具体内容参考：Java8新特性流式数据处理
不光是集合，包括数组，文件，音频等，只要可以转换成流的，我们都可以借助于流式处理

/**
 * 题目要求： 用一行代码实现
 * 1. Id 必须是偶数
 * 2.年龄必须大于23
 * 3. 用户名转为大写
 * 4. 用户名倒序
 * 5. 只能输出一个用户
 **/

public class StreamDemo {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 23);
        User u2 = new User(2, "b", 23);
        User u3 = new User(3, "c", 23);
        User u4 = new User(6, "d", 24);
        User u5 = new User(4, "e", 25);

        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // lambda、链式编程、函数式接口、流式计算
        list.stream()
                .filter(user -> {return user.getId()%2 == 0;})
                .filter(user -> {return user.getAge() > 23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((user1, user2) -> {return user2.compareTo(user1);})
                .limit(1)
                .forEach(System.out::println);
    }
}
class User{
    private int id;
    private String name;
    private int age;
    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}