JUC并发编程(基础入门四)—— 四大函数式接口、Stream 流式计算

1四大函数式接口

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

1Function 函数型接口

import java.util.function.Function;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Function<String, String> function = (str) -> {
    
    return str;};
        System.out.println(function.apply("aaaaaaaaaa"));
    }
}

2Predicate 断定型接口

public class Test{
    
    
    public static void main(String[] args) {
    
    
        Predicate<String> predicate = (str) -> {
    
    return str.isEmpty();};
        // false
        System.out.println(predicate.test("aaa"));
        // true
        System.out.println(predicate.test(""));
    }
}

3Suppier 供给型接口

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

4Consummer 消费型接口

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

2Stream 流式计算

什么是stream流式计算？
计算都应该交给流操作！

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

public class Test {
    
    
    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;}) //Stream<T> filter(Predicate<? super T> predicate);
                .filter(user -> {
    
    return user.getAge() > 23;})
                .map(user -> {
    
    return user.getName().toUpperCase();}) //<R> Stream<R> map(Function<? super T, ? extends R> mapper);
                .sorted((user1, user2) -> {
    
    return user2.compareTo(user1);})//   Stream<T> sorted(Comparator<? super T> comparator);
                .limit(1)
                .forEach(System.out::println);
    }
}