JDK1.8新特性之Lambda表达式学习

什么是Lambda？

Lambda是一个匿名函数，即一个没有函数名的函数（简化了匿名委托的使用，让你的代码更加简洁）

匿名委托就是匿名内部类

下面举两个例子:

 Thread thread = new Thread(new Runnable() {
            @Override  //这个就是一个匿名内部类
            public void run() {
                System.out.println("这是个Runable接口实例，用的是匿名内部类");
            }
        });
        thread.start();//使用了7行代码调用了这个内部类
        Thread thread2 = new Thread(()-> System.out.println("这是个Runable接口实例，用的是Lambda表达式"));
        thread2.start();
        //控制台结果：
        //这是个Runable接口实例，用的是匿名内部类
        //这是个Runable接口实例，用的是Lambda表达式

        //现在有一组set集合，添加字符串进行排序
        TreeSet<String> treeSet = new TreeSet<>();//treeSet与普通set相比是根据首字母自动排序的
        treeSet.add("a");
        treeSet.add("dd");
        treeSet.add("ccc");
        treeSet.add("bbbb");
        System.out.println(treeSet);//输出结果为[a, bbbb, ccc, dd]，此时是首字母排序

        //现在我们需要按照字符串长度进行排序
        TreeSet<String> treeSet1 = new TreeSet<>(new Comparator<String>() { //new Comparator<String>为排序器
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(),o2.length());
            }
        });
        treeSet1.add("a");
        treeSet1.add("dd");
        treeSet1.add("ccc");
        treeSet1.add("bbbb");
        System.out.println(treeSet1);//输出结果为[a, dd, ccc, bbbb]

        //内部类又有很多，我们可以使用Lambda进行替换
        TreeSet<String> treeSet2 = new TreeSet<>((a, b) -> Integer.compare(a.length(),b.length()));
        treeSet2.add("a");
        treeSet2.add("dd");
        treeSet2.add("ccc");
        treeSet2.add("bbbb");
        System.out.println(treeSet2);//输出结果仍然为[a, dd, ccc, bbbb]

 

我们发现Lambda表达式可以简化我们使用匿名内部类的使用，那么具体是如何使用呢？

package com.bruno_cheng.jdk;

import java.util.Comparator;

public class LambdaDemo2 {
    public static void main(String[] args) {
        //Lambda代码格式一：无参数，无返回值
        //()->System.out.println("规范一");
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是个匿名内部类");
            }
        };
        runnable = ()->System.out.println("这是个匿名内部类");


        //语法格式二：有一个参数，并且无返回值
        //(x) -> System.out.println("规范二");

        //语法格式三：若只有一个参数，小括号可以省略不写
        //x->System.out.println("规范三");

        //语法规范四：有两个以上的参数，有返回值，并且Lambda体中有多条语句
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int i = Integer.compare(o1.length(),o2.length());
                System.out.println("规范四");
                return  i;
            }
        };
        comparator = (o1, o2) -> {
            int i = Integer.compare(o1.length(),o2.length());
            System.out.println("规范四");
            return  i;};

        //语法规范五：Lambda语句只有一个执行体，return和大括号可以不写：
        Comparator<String> comparator2 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return  Integer.compare(o1.length(),o2.length());
            }
        };
        comparator2 = (o1, o2) ->Integer.compare(o1.length(),o2.length());

        //语法规范六：lambda表达式的参数列表的数据类型可以不写
        // （JVM会通过上下文可以推断出数据类型，例如通过<?>泛型就可以推断数据类型）
        //  Integer.compare(int a,int b);  -->>  Integer.compare(a,b);
    }
}

 

```
通过上面的规范实例我们可以看出使用Lambda可以有效的简化代码。

下面通过一个简答的练习感受下：

- 1.定义一个接口：接收两个参数（两个参数类型一样的泛型），返回int
- 2.定义一个person类，3个属性name，age，score

现在要求:
- 1.实现接口，比较两个的age大小；
- 2.实现接口，比较两个的score大小；
- 3.使用内置的compare接口对数组排序；

接口：

package com.bruno_cheng.jdk.com.bruno_cheng;

public interface TestInterface<T>{
    //定义一个接口：接收两个参数（两个参数类型一样的泛型），返回int
    int method( T t1,T t2);
}

 person类：

package com.bruno_cheng.jdk.com.bruno_cheng;

public class Person {
    private String name;
    private int age;
    private int score;

    //getter &setter

    public void init(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

测试类：

package com.bruno_cheng.jdk.test;

import com.bruno_cheng.jdk.bruno_cheng.Person;
import com.bruno_cheng.jdk.bruno_cheng.TestInterface;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        List<Person> person = new ArrayList<>();
        person.add(new Person("张三",18,100));
        person.add(new Person("李四",19,90));
        person.add(new Person("王五",19,95));
        //- 1.实现接口，比较两个的age大小；
        //不使用Lambda
        TestInterface<Person> personTestInterface2 = new TestInterface<Person>() {
            @Override
            public int method(Person p1, Person p2) {
                return Integer.compare(p1.getAge(),p2.getAge());
            }
        };
        //使用Lambda后
        TestInterface<Person> personTestInterface = (p1,p2) ->Integer.compare(p1.getAge(),p2.getAge());
        //- 2.实现接口，比较两个的score大小；
        personTestInterface = (p1,p2) ->Integer.compare(p1.getScore(),p2.getScore());
        //此时我们可以发现，我们这里只需要该Lambda表达式右边的改动即可，不需想上面那样重复很多代码。
        //- 3.使用内置的compare接口对分数排序；


//        person.sort(new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return Integer.compare(o1.getScore(),o2.getScore());
//            }
//        });
        System.out.println(person);
        //[Person{name='李四', age=19, score=90}, Person{name='王五', age=19, score=95}, Person{name='张三', age=18, score=100}]

        person.sort((Person o1, Person o2) ->Integer.compare(o1.getScore(),o2.getScore()));
        System.out.println(person);
    }
}

此时我们可以发现Lamda需要函数式接口：

什么是函数式接口？

函数式接口就是接口中只有一个抽象方法的的接口。可以使用注解@FunctionalInterface修饰可以检查是否是函数式接口

package com.bruno_cheng.jdk.bruno_cheng;
@FunctionalInterface  //检查是否是函数式接口
public interface TestInterface<T>{
    //定义一个接口：接收两个参数（两个参数类型一样的泛型），返回int
    int method( T t1,T t2);
}

 

 JAVA内置的函数式接口

代码测试如下：

package com.bruno_cheng.jdk.test;

import com.bruno_cheng.jdk.bruno_cheng.Person;

import java.util.function.*;

/**
 * 测试java内置函数式接口
 */
public class Test2 {
    public static void main(String[] args) {
        //1.在内部类实现,传入参数,返回boolean类型(Predicate)
        //使用Predicate接口,,判断返回值类型判断某个person对象是否大于18岁
        Predicate<Person> predicate = (p)->p.getAge()>18;
        boolean b = predicate.test(new Person("张三",20,90));
        System.out.println(b);//true

        //2.在内部类实现,传入参数,没有返回值(Consumer)
        //使用Consumer接口,传入一个字符串,>>打印<<字符串长度.
        Consumer<String> consumer = str -> System.out.println("\""+str+"\"的长度"+str.length());
        consumer.accept("早上好啊");//"早上好啊"的长度4

        //3.在内部类实现,传入参数,没有返回值(Function)
        //使用Consumer接口,传入一个字符串,>>返回<<字符串长度.
        Function<String,Integer> function = s -> s.length();
        Integer integer = function.apply("中午好");
        System.out.println(integer);//3

        //4.在内部类实现,不传入参数,有返回值(Supplier)
        //使用Supplier接口,创建一个姓名等于张三,年龄18,分数80分的对象.
        Supplier<Person> supplier = ()->  new Person("张三", 18, 80);
        System.out.println(supplier.get()); //Person{name='张三', age=18, score=80}

        //5.在内部类实现,传入一个参数,返回一个参数(UnaryOperator)
        //使用UnaryOperator接口,传入一个字符串,返回全部转为大写的新字符串
        UnaryOperator<String> unaryOperator = (str) ->str.toUpperCase();
        //UnaryOperator继承Function
        System.out.println(unaryOperator.apply("abcd"));//ABCD
    }

}

PS:这里就可以看出:函数式编程式对行为的封装。