Java~新时代程序员的编码风格：lambda表达式、函数式接口、Stream流式计算、链式编程、异步调用

前言

如果有同学去逛一些新出来的开源项目和框架，你肯定会看到大量的lambda表达式、函数式接口、链式编程、Stream流式计算。

所以现在如果还不熟悉这几个技术，你就会发现看源码非常吃力。

Lambda表达式

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

• paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
• ->：可理解为“被用于”的意思
• statements：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

语法精简

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略
3. 如果方法体当中只有一句代码，那么大括号可以省略
4. 如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且去掉return关键字。

那么lambda为什么好用呢？
首先一点它主要用在函数式接口上，那下面我再讲讲函数式接口。

Lambda表达式的好坏

Lambda表达式的优点很明显，从核心原理来说他使用的是匿名内部类，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。

• 优点：
  代码简洁，开发迅速
  方便函数式编程， 只要是函数型接口，都能使用lambda表达式简化
  非常容易进行并行计算
  Java 引入 Lambda，改善了集合操作
• 缺点：
  代码可读性变差
  在非并行计算中，很多计算未必有传统的 for 性能要高
  不容易进行调试

函数式接口

首先看其定义：

1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的，保证安全。

@FunctionalInterface 
public interface Runnable { 
    public abstract void run(); 
}

四大函数式接口

Function函数式接口

Function 函数型接口, 有一个输入参数，有一个输出

    public static void main(String[] args) {
        //输出大写后的原字符串
        Function<String, String> function = str -> str.toUpperCase();

        System.out.println(function.apply("abc"));
    }

Predicate断定型接口

有一个输入参数，返回值只能是 布尔值！

    public static void main(String[] args) {
        //判断一个字符串是否为a开头
        Predicate<String> predicate = s -> !s.isEmpty() && s.charAt(0) == 'a';

        System.out.println(predicate.test("abc"));
    }

Consumer 消费型接口

只有输入没有输出

    public static void main(String[] args) {
        //输出一个大写字符串
        Consumer<String> consumer = s -> System.out.println(s.toUpperCase());

        consumer.accept("abc");
    }

Supplier 供给型接口

没有输出值，只有输出值

    public static void main(String[] args) {
        //返回一个Demo对象
        Supplier<Demo> supplier = () -> {return new Demo();};

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

Stream流式计算

这个我之前有文章就不过多讲了，基础流式计算基础东西可以看我之前的博客链接
今天我要加一点东西就是并行流，让大家体验一下他的好处。

我们现在常说的大数据，其实大数据不外乎存储技术和计算技术，其中计算技术大多都是用流来计算。

比如我们现在计算0~10_0000_0000L的和，我写代码大家体验一下他的快速

    public static void main(String[] args) {
        //普通for循环
        long sum1 = 0L;
        long start1 = System.currentTimeMillis();
        for (long i = 0L; i < 10_0000_0000L; i++) {
            sum1 += i;
        }
        System.out.println("普通for循环耗时：" + (System.currentTimeMillis() - start1));

        long start2 = System.currentTimeMillis();
        long sum2 = LongStream.range(0, 10_0000_0000L).parallel().sum();
        System.out.println("使用并行流耗时：" + (System.currentTimeMillis() - start2));
    }

普通for循环耗时：520
使用并行流耗时：290

几乎可以快出一倍。

链式编程

题目要求：一分钟内完成此题，只能用一行代码实现！

• 现在有5个用户！筛选：
  1、ID 必须是偶数
  2、年龄必须大于23岁
  3、用户名转为大写字母
  4、用户名字母倒着排序
  5、只输出一个用户！

用户的数据结构

    static class User {
        int id;
        String name;
        int age;

        public User(int id, String name, int age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

实现代码：

    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);

        list.stream().filter(user -> user.id % 2 == 0) //过滤
                .filter(user -> user.age > 23)  //过滤
                .peek((user) -> user.name = user.name.toUpperCase()) //简单数据
                .sorted((uu1, uu2) -> uu2.name.compareTo(uu1.name)) //排序
                .limit(1)  //限制数量
                .forEach(System.out::println); //输出
    }

而并行流的核心原理是ForkJoinPool，这个我之前也写过文章，可以参考参考。
链接

Future异步调用

Future 设计的初衷： 对将来的某个事件的结果进行建模，也就是他会异步的执行然后帮助我们保存结果，我们想要结果的时候直接get就行，如果结果还没有出来，get的时候就会阻塞。

最常用的就是他下面的一个实现类： CompletableFuture

而且它的泛型参数是设置的返回值类型。

他有俩种启动方法

runAsync看参数就是一个runnable参数异步执行肯定时没有返回值的，而上面说到的supplyAsync是一个生产者接口，所以他的作用就是有返回值的。

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //无返回值的异步调用, 俩秒后输出我爱你
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("进入: " + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("我爱你");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("离开: " + Thread.currentThread().getName());
        });

        System.out.println("swy:");
        //获取其执行结果，如果异步任务没有执行完，此时主线程就会阻塞
        future.get();
    }

再来看一个异步执行等待返回值的例子

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //比如我们实现一个web响应状态码，正常返回200，出错返回500
        String url = "http://www.baidu.com";
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {

            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            // URL验证规则
            String regEx ="[a-zA-z]+://[^\\s]*";
            // 编译正则表达式
            Pattern pattern = Pattern.compile(regEx);
            // 忽略大小写的写法
            Matcher matcher = pattern.matcher(url);
            // 字符串是否与正则表达式相匹配
            if (!matcher.matches()) {
                throw new IllegalStateException();
            }
            return 200;
        }).whenComplete((t, u) -> { //查看执行完的返回结果或者错误信息
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u); // 错误信息：
        }).exceptionally((e) ->{ //如果出现异常
            System.out.println(e.getMessage());
            return 500;
        });

        System.out.println(completableFuture.get());

    }