初识Java8新特性Lambda（一）

前言

Java8已经出来很久了，但是现在很多公司并没有急于升级到新的版本，Java8仍然是主流的开发版本。我是带着学习的态度开始了解并学习lambda，这是Java8版本中比较大的一个变化，也是比较吸引我的一个技能。

lambda表达式的介绍

[官网介绍](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
One issue with anonymous classes is that if the implementation of your anonymous class is very simple, such as an interface that contains only one method, then the syntax of anonymous classes may seem unwieldy and unclear. In these cases, you're usually trying to pass functionality as an argument to another method, such as what action should be taken when someone clicks a button. Lambda expressions enable you to do this, to treat functionality as method argument, or code as data.
匿名类有一个问题，如果匿名类的实现非常简单，比如一个只包含一个方法的接口，那么这样的匿名类的语法是笨拙和不清晰的。在这些情况下，你通常会尝试将功能作为参数传递给另一个方法，比如某人点击按钮时，它将发生的具体行为。lambda表达式允许你这样做，将功能作为方法的参数，或者把代码当作数据。

lambda表达式的基本语法

    语法：(params) -> expression
               (params) -> statement
               (params) -> { statements }
     即: 参数 -> 带返回值的表达式/无返回值的陈述
    说明：parameters：参数，多个以逗号隔开。
               expression ：语句，即一句话或者一个操作。
               statements ：陈述，一个或多个语句。

    //接收2个int型整数,返回他们的和
    (int x, int y) -> x + y;

    // 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
    (String s) -> System.out.print(s);

lambda表达式和普通方法使用对比（官方实例）

    List<Person> roster = Person.createRoster();

1. 遍历list列表数据

普通方式

 for (Person p : roster) {
    p.printPerson();
}

   /**
      * @Description 普通方式筛选
      * @param list
      * @Return void
      * @Author Mr.Walloce
      * @Date 2019/9/27 10:18
      */
    public static void oldFilter(List<Person> list) {

        for (Person person : list) {
            if (person.getAge() > 15 && person.getAge() < 25) {
                person.printPerson();
            }
        }
    }

使用lambda表达式

    roster..forEach(person -> person.printPerson());

    /**
      * @Description lambda方式筛选
      * @param list
      * @Return void
      * @Author Mr.Walloce
      * @Date 2019/9/27 10:19
      */
    public static void newFilter(List<Person> list) {
        list.stream()
                .filter(person -> person.getAge() > 15)
                .filter(person -> person.getAge() < 25)
                .forEach(person -> person.printPerson());
    }

2. 集合排序

普通方式

    /**
      * @Description 普通方法排序
      * @param list
      * @Return void
      * @Author Mr.Walloce
      * @Date 2019/9/27 10:16
      */
    public static void oldSort(List<Person> list){
        //排序
        Collections.sort(list,new Comparator<Person>() {
            //根据年龄进行排序
            @Override
            public int compare(Person a,Person b){
                if (a.getAge() <= b.getAge()) {
                    return 1;
                }else{
                    return -1;
                }
            }
        });
    }

使用lambda表达式

    /**
      * @Description lambda表达式排序
      * @param list
      * @Return void
      * @Author Mr.Walloce
      * @Date 2019/9/27 10:16
      */
    public static void newSort(List<Person> list){
        //lambda会根据list自动推断出 a,b 的类型
        Collections.sort(list, (a, b) -> a.getAge() < b.getAge() ? 1:-1);
    }

3. runable线程

普通方式

    /**
      * @Description 普通的Runnable
      * @param
      * @Return void
      * @Author Mr.Walloce
      * @Date 2019/9/27 10:28
      */
    public static void oldRunnable(){

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("oldRunnable running");
                List<Person> people = Person.createRoster();
                for (Person person : people) {
                    person.printPerson();
                }
            }
        };
        new Thread(runnable).start();
    }

lambda表达式

    /**
      * @Description lambda表达式方式
      * @param
      * @Return void
      * @Author Mr.Walloce
      * @Date 2019/9/27 10:29
      */
    public static void newRunnable(){
        new Thread(() -> {
            System.out.println("newRunnable running");
            List<Person> people = Person.createRoster();
            people.forEach(person -> person.printPerson());
        }).start();
    }

Lambda表达式的使用场景

• 函数式接口（Functional Interface）
  定义的一个接口，接口里面必须有且只有一个抽象方法，这样的接口就成为函数式接口。
  在可以使用lambda表达式的地方，方法声明时必须包含一个函数式的接口。 （JAVA8的接口可以有多个default方法）
  任何函数式接口都可以使用lambda表达式替换。

• 注意
  lambda表达式只能出现在目标类型为函数式接口的上下文中。
  此处是只能！！！
  意味着如果我们提供的这个接口包含一个以上的Abstract Method，那么使用lambda表达式则会报错。

• 使用场景
  你在某处就真的只需要一个能做一件事情的函数而已，连它叫什么名字都无关紧要（匿名函数）。
  Lambda 表达式就可以用来做这件事。

结论

1. lambda表达式在很多地方使用起来确实精简很多，语法也很容易理解；
2. 由于lambda是java8以来新增的特性，很多人并没有深入了解过，如果协作开发可能不太和谐；
3. 由于学过sacala，感觉java的语法在向scala的语法靠近，代码更少，功能更强！

附参考链接：
State of the Lambda
java8官方文档（中文翻译）—Lambda表达式