四大函数式接口以及Stream流式计算

经过近几年计算机行业的发展，新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算

1.函数式接口

函数式接口： 只有一个方法的接口 Runnable就是一个典型的例子

@FunctionalInterface 
public interface Runnable {
    public abstract void run(); 
}
// 泛型、枚举、反射 
// lambda表达式、链式编程、函数式接口、Stream流式计算 
// 超级多FunctionalInterface 
// 简化编程模型，在新版本的框架底层大量应用！ 
// foreach(消费者类的函数式接口)

四大函数式接口：

2.function函数式接口

简单代码实现：

import java.util.function.Function;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-26 19:35
 **/
public class FunctionTest {

    public static void main(String[] args) {

        Function<String, String> function = new Function<String, String>(){
            @Override
            public String apply(String s) {
                return s;
            }
        };

        //lambda表达式
        Function<String , String> function1 = (str) -> { return str;};


        System.out.println(function.apply("hello"));
        System.out.println(function1.apply("world"));

    }
}

执行结果：

3.Predicate 断定型接口

简单代码实现：

import java.util.function.Predicate;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-26 19:51
 **/
public class PredicateTest {

    public static void main(String[] args) {

        Predicate<String> predicate = new Predicate<String>(){
            @Override
            public boolean test(String o) {
                if(o.isEmpty()){
                    return true;
                }
                return false;
            }
        };

        Predicate<String> predicate1 = (str) -> {return str.isEmpty();};

        System.out.println(predicate.test(""));
        System.out.println(predicate1.test("hello"));
    }
}

执行结果：

4.Consumer消费型接口

简单代码实现：

import java.util.function.Consumer;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-26 20:00
 **/
public class ConsumerTest {

    public static void main(String[] args) {

        Consumer<String> consumer = new Consumer<String>(){
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        Consumer<String> consumer1 = (str) -> {
            System.out.println(str);
        };

        consumer.accept("hello");

        consumer1.accept("world");
    }
}

执行结果：

4.Supplier供给型接口

简单代码实现：

import java.util.function.Supplier;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-26 20:05
 **/
public class SupplierTest {

    public static void main(String[] args) {
        Supplier<Integer> supplier = new Supplier<Integer>(){
            @Override
            public Integer get() {
                return 1024;
            }
        };

        Supplier<Integer> supplier1 = () -> {return 1024;};

        System.out.println(supplier.get());
        System.out.println(supplier1.get());
    }
}

执行结果：

5.Stream流式计算

这里我们通过有个小问题来说明流式计算
/**

• 题目要求：一分钟内完成此题，只能用一行代码实现！
• 现在有5个用户！筛选：
• 1、ID 必须是偶数
• 2、年龄必须大于23岁
• 3、用户名转为大写字母
• 4、用户名字母倒着排序
• 5、只输出一个用户！
  */

期待输出：E
简单代码实现：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-26 20:36
 **/
public class SteamTest {

    public static void main(String[] args) {

        User u1 = new User(1,"a",21);
        User u2 = new User(2,"b",22);
        User u3 = new User(3,"c",23);
        User u4 = new User(4,"d",24);
        User u5 = new User(6,"e",25);
        // 集合就是存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        // 计算交给Stream流
        // lambda表达式、链式编程、函数式接口、Stream流式计算
        Stream<User> stream = list.stream();
        stream
                .filter(u -> { return u.getId()%2 == 0;})
                .filter(u -> {return u.getAge()>23;})
                .map(u -> {return u.getName().toUpperCase();})
                .sorted((uu1,uu2) -> {return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

执行结果：

今天的讨论就到这里了哦 ，欢迎小伙伴们留言讨论！