JUC之四大函数接口以及Stream流计算（总体五篇）_java stream四大函数接口

1、四大函数接口

• java.util.funciton.它有四大函数接口。
  

Function<String,Integer> function = new Function<String, Integer>() {
            public Integer apply(String s) {
                return s.length();
            }
        };
        System.out.println(function.apply("ACV"));

        Function<String,Integer> function1 = s -> {
            return 123;
        };
        System.out.println(function1.apply("ACV"));
1
2
3
4
5
6
7
8
9
10
11

其他的也是一样的，都是这样写，比较简单。

• 它的使用场景：其实它使用场景就是我现在越来越面向接口编程吗，而我们要自定义接口使用的时候，此时java公司开发人员也想到了有这样的需求，所有就提供了这么几个接口供我们使用。

2、Stream流式计算

java8之前我们的List集合，可以与数组之间转化，而java开始List除了与数组转换外，还可以与Stream流进行转换。【集合管的数据，而stream是管的计算】

• 我们的List转换为Steam使用内部的方法stream即可调用
  
• 而Stream转为List是直接调用Stream的collect即可。

（1）看问题描述

User user1 = new User(11,"a",2);
        User user2 = new User(12,"a",24);
        User user3 = new User(13,"a",22);
        User user4 = new User(14,"a",28);
        User user5 = new User(16,"a",26);

        List<User> usersList = new ArrayList<User>(){};
        usersList.add(user1);
        usersList.add(user2);
        usersList.add(user3);
        usersList.add(user4);
        usersList.add(user5);
1
2
3
4
5
6
7
8
9
10
11
12

把上面的数据想象成非常大的数据，现在你要把id过滤为整数的，还有年龄大于24的，然后把名字大写，倒叙输出，并且输出一个，怎么处理呢、

（2）过滤器的使用

ublic static void main(String[] args) {
        User user1 = new User(11,"a",2);
        User user2 = new User(12,"a",24);
        User user3 = new User(13,"a",22);
        User user4 = new User(14,"a",28);
        User user5 = new User(16,"a",26);

        List<User> usersList = new ArrayList<User>(){};
        usersList.add(user1);
        usersList.add(user2);
        usersList.add(user3);
        usersList.add(user4);
        usersList.add(user5);




        //过滤ID为整数的，
        usersList
                .stream()
                .filter(t -> {
            return t.getId() % 2 == 0; })
                .forEach(System.out::println);



    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• 我们二次过滤年龄大于24的
  

public class TestController {
    public static void main(String[] args) {
        User user1 = new User(11,"a",2);
        User user2 = new User(12,"a",24);
        User user3 = new User(13,"a",22);
        User user4 = new User(14,"a",28);
        User user5 = new User(16,"a",26);

        List<User> usersList = new ArrayList<User>(){};
        usersList.add(user1);
        usersList.add(user2);
        usersList.add(user3);
        usersList.add(user4);
        usersList.add(user5);




        //过滤ID为整数的，
        (usersList
                .stream()
                .filter(t -> {
                    return t.getId() % 2 == 0; })
        )
                .filter(t -> {return t.getAge() > 24;})
                .forEach(System.out::println);



    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

（3）映射方法（map）的使用

• 转换用户名大小写

public static void main(String[] args) {
        User user1 = new User(11,"a",2);
        User user2 = new User(12,"B",24);
        User user3 = new User(13,"C",22);
        User user4 = new User(14,"D",28);
        User user5 = new User(16,"E",26);

        List<User> usersList = new ArrayList<User>(){};
        usersList.add(user1);
        usersList.add(user2);
        usersList.add(user3);
        usersList.add(user4);
        usersList.add(user5);




        //过滤ID为整数的，
        (usersList
                .stream()
                .filter(t -> {
                    return t.getId() % 2 == 0; })
        )
                .filter(t -> {return t.getAge() > 24;})
                .map(x -> {
                    return x.getName().toUpperCase();
                })
                .forEach(System.out::println);



    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

（4）进行排序

public static void main(String[] args) {
        User user1 = new User(11,"a",2);
        User user2 = new User(12,"B",24);
        User user3 = new User(13,"C",22);
        User user4 = new User(14,"D",28);
        User user5 = new User(16,"E",26);

        List<User> usersList = new ArrayList<User>(){};
        usersList.add(user1);
        usersList.add(user2);
        usersList.add(user3);
        usersList.add(user4);
        usersList.add(user5);




        //过滤ID为整数的，
        (usersList
                .stream()
                //这里过滤ID是整数的
                .filter(t -> {
                    return t.getId() % 2 == 0; }))
                //这里过滤年龄大于24的
                .filter(t -> {return t.getAge() > 24;})
                //这里进行大小写转换
                .map(x -> {
                    return x.getName().toUpperCase();
                })
                //进行倒叙排序
                .sorted((o1, o2) -> {return o2.compareTo(o1);})
                .forEach(System.out::println);



    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

（5）输出一个（模拟限定查询）

public class TestController {
    public static void main(String[] args) {
        User user1 = new User(11,"a",2);
        User user2 = new User(12,"B",24);
        User user3 = new User(13,"C",22);
        User user4 = new User(14,"D",28);
        User user5 = new User(16,"E",26);

        List<User> usersList = new ArrayList<User>(){};
        usersList.add(user1);
        usersList.add(user2);
        usersList.add(user3);
        usersList.add(user4);
        usersList.add(user5);




        //过滤ID为整数的，
        (usersList
                .stream()
                //这里过滤ID是整数的
                .filter(t -> {
                    return t.getId() % 2 == 0; }))
                //这里过滤年龄大于24的
                .filter(t -> {return t.getAge() > 24;})
                //这里进行大小写转换
                .map(x -> {
                    return x.getName().toUpperCase();
                })
                //进行倒叙排序
                .sorted((o1, o2) -> {return o2.compareTo(o1);})
                //模拟限定查询
                .limit(1)
                .forEach(System.out::println);



    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

同样的，max啊，min啊，avg等数据库的sql都可以用。

3、Forkjoin（分支合并框架）

分支合并。【就比如0 +…1000，一个人加给我结果，另外种情况是分成多个小分分别算，然后合并把结果给我】

class MyTask extends RecursiveTask<Integer> {

    public static final int FIX = 10;

    private int begin;
    private int end;
    private int result;

    public MyTask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if ((end - begin) <= FIX) {
            for (int i = begin; i <= end ; i++) {
                result = result + i;
            }
        } else {
            int middle = (end + begin) / 2;
            MyTask task = new MyTask(begin,middle);
            MyTask task1 = new MyTask(middle + 1,end);
            task.fork();
            task1.fork();
            result = task.join() + task1.join();
        }
        return result;
    }

}

public class ForkjoinDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyTask myTask = new MyTask(0,100);
        //1、先获得池子
        ForkJoinPool forkJoinPool = new ForkJoinPool();

        //2、处理数据
        ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);
        System.out.println(forkJoinTask.get());
        //关闭池子
        forkJoinPool.shutdown();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

其实感觉就是一个算法（排序算法）。

4、异步回调

• 同步是在我访问你，访问一直在这里等着，等你处理完了就结束。

• 异步回调，其实就是另外一个线程在干活。

public class CompletableFutureDemo {
    public static void main(String[] args) {
        try {
            //没有返回值的情况
            CompletableFuture.runAsync(() -> {
                System.out.println(Thread.currentThread().getName() + "没有返回值，update mysql OK");
            }).get();


            //有返回值的情况
            CompletableFuture.supplyAsync(() -> {
                System.out.println("输出");
               return "返回值";
            }).whenComplete((o1,o2) -> {
                System.out.println("运算的结果（没有错误的情况） " + o1);
                System.out.println("运算的结果（有错误的情况） " + o2);
            }).exceptionally(f -> {
                System.out.println("错误"  + f.getMessage());
                return "有错误";
            });

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30