函数式编程 + 流式计算

java.util.function函数式接口

四大函数式接口

函数式接口	参数类型	返回类型	用途
Consumer消费型接口	T	void	对类型为T的对象应用操作，包含方法 void accept（T t）
Supplier供给型接口	无	T	返回类型为T的对象，返回类型为T的对象，包含方法 T get()
Function<T,R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。包含方法 R apply(T t)
Predicate断定型接口	T	boolean	确定类型为T的对象是否满足某约束条件，包含方法 boolean test(T t)

Function

    public static void main(String[] args){
        Function<String,String> function1 = new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s;
            }
        };
        Function<String,String> function2 = (str)->{return str;};
//        Function<String,String> function2 = (str)-> str;

        System.out.println(function1.apply("hurw"));
        System.out.println(function2.apply("hurw"));
    }

Predicate

    public static void main(String[] args){


        Predicate<String> predicate1 = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };

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

        System.out.println(predicate1.test("aa"));
        System.out.println(predicate2.test(""));
    }

Consumer

    public static void main(String[] args) {
 
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
 
        Consumer<String> consumer2 = (str)->{ System.out.println(str);};
 
        consumer1.accept("aa");
        consumer2.accept("bb");
    }

Supplier

    public static void main(String[] args) {
 
        Supplier supplier1 = new Supplier() {
            @Override
            public Object get() {
                return 10;
            }
        };
 
        Supplier supplier2 = ()->{return 24;};
 
        System.out.println(supplier1.get());
        System.out.println(supplier2.get());
 
    }

    @Test
    public void testCoreInter(){
        /**
         * @name 消费型接口
         * @use Consumer<T>
         * @param T 传入参数
         * @fun 接受一个参数 无返回值
         * */
        Consumer<String> con=(str)->System.out.println(str);
        con.accept("我是消费型接口!");

        /**
         * @name 供给型接口
         * @use Supplier<R>
         * @param R 返回值类型
         * @fun 无参数 有返回值
         * */
        Supplier<Date> supp=()-> new Date();
        Date date=supp.get();
        System.out.println("当前时间:"+date);

        /**
         * @name 函数型接口
         * @use Function<T,R>
         * @param T 传入参数
         * @return R 返回值类型
         * @fun 接受一个参数 有返回值
         * */
        Function<String, String> fun=(str)->"hello,"+str;
        String str=fun.apply("hahaha");
        System.out.println(str);
        /**
         * @name 断定型接口
         * @use Predicate<T>
         * @param T 传入参数
         * @return Boolean 返回一个Boolean型值
         * @fun 接受一个参数 返回Boolean型值
         * */
        Predicate<Integer> pre=(num)->num>0;
        Boolean flag=pre.test(10);
        System.out.println(flag);
    }

java.util.stream 流式计算

操作数据源（集合、数组等）

• Stream 自己不会存储元素
• 不会改变源对象，会返回一个持有结果的新Stream
• 操作时延迟执行的。会等到需要结果的时候才执行

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class ChainDemo {
    private Integer id;
    private String name;
    private Integer age;
    private String school;
}

class TestChain{
    // 链式编程  +  流式计算
    public static void main(String[] args){
        ChainDemo chainDemo1 = new ChainDemo().setId(11).setAge(21).setName("a").setSchool("清华");
        ChainDemo chainDemo2 = new ChainDemo().setId(12).setAge(22).setName("b").setSchool("清华");
        ChainDemo chainDemo3 = new ChainDemo().setId(13).setAge(23).setName("c").setSchool("清华");
        ChainDemo chainDemo4 = new ChainDemo().setId(14).setAge(24).setName("d").setSchool("北大");
        ChainDemo chainDemo5 = new ChainDemo().setId(15).setAge(25).setName("e").setSchool("北大");
        ChainDemo chainDemo6 = new ChainDemo().setId(16).setAge(26).setName("f").setSchool("北大");

        List<ChainDemo> list = Arrays.asList(chainDemo1, chainDemo2, chainDemo3, chainDemo4, chainDemo5, chainDemo6);
        // 使用stream的filter过滤器，传入Predicate<T>断定型函数式接口
        // 返回 id 是偶数的
        list.stream().filter( t -> t.getId() % 2 == 0).forEach(System.out::println);
        System.out.println("=======================================================");
        //再次过滤，返回 age 》 23
        list.stream().filter( t -> t.getId() % 2 == 0).filter(t -> t.getAge() > 23).forEach(System.out::println);
        System.out.println("=======================================================");
        //只取一个
        list.stream().filter( t -> t.getId() % 2 == 0)
                     .filter(t -> t.getAge() > 23)
                     .limit(1)
                     .forEach(System.out::println);
        System.out.println("=======================================================");
		//计算最大值
		Integer maxAge =list.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge())).get().age;
		Integer maxAge2 = list.stream().collect(Collectors.maxBy(Comparator.comparing(ChainDemo::getAge))).get().age;
		 System.out.println("=======================================================");
		//计算最小值
		Integer minAge = list.stream().collect(Collectors.minBy((S1,S2) -> S1.getAge()- S2.getAge())).get().age;
		Integer minAge2 = list.stream().collect(Collectors.minBy(Comparator.comparing(ChainDemo::getAge))).get().age;
		 System.out.println("=======================================================");
		//计算总和
		Integer sumAge =list.stream().collect(Collectors.summingInt(ChainDemo::getAge));
		 System.out.println("=======================================================");
		//计算平均值
		double averageAge = list.stream().collect(Collectors.averagingDouble(ChainDemo::getAge));
		 System.out.println("=======================================================");
		//一次性查询元素个数、总和、最大值、最小值和平均值
		IntSummaryStatistics summaryStatistics = list.stream().collect(Collectors.summarizingInt(ChainDemo::getAge));
		//按照age从大到小排序
		list.stream().sorted((s1,s2) -> s2.getAge() - s1.getAge()).forEach(System.out::println);
		//跳过前两个元素后的list
		list.stream().skip(2).forEach(System.out::println);
		//根据学校分组
		Map<String, List<ChainDemo>> collect = list.stream().collect(Collectors.groupingBy(ChainDemo::getSchool));
		//每个学校人数
		Map<String, Long> collect3 = list.stream().collect(Collectors.groupingBy(ChainDemo::getSchool, Collectors.counting()));
        System.out.println(collect3);
    }
}

CompletableFuture 异步回调

public class CompletableFutureDemo {
    public static void main(String[] args) throws Exception{
    	//入参是Runnable接口
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 没有返回值");
        });
        // 相当于直接调用 Runnable 接口的run方法
        voidCompletableFuture.get();

        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "\t 有返回值");
            //int i = 10 / 0;
            return 1024;
        });
        Integer integer = integerCompletableFuture.whenComplete((t, u) -> {
        	// 必定执行的内容
            System.out.println("t=========" + t);
            System.out.println("u=========" + u);
        }).exceptionally(f -> {
        	// 抛出异常才执行的内容
            System.out.println(f.getMessage());
            return 5555;
        }).get();
        System.out.println(integer);
    }
}