java8中的Lambda表达式

现在有一个实体类Person，Person中有age年龄和salary工资属性

还有一个集合

static List<Person> persons = Arrays.asList(
            new Person(19,2000),
            new Person(13,3002),
            new Person(32,4000),
            new Person(78,1003)
    );

现在有一个需求是取集合中年龄大于20 的人，取集合中工资大于2000的人。

为了以后有新需求，可以采用策略设计模式

创建一个泛型接口

public interface MyPredicate<T> {

   Boolean test(T t);

}

在测试类中创建一个方法

public static List<Person> filterPerson(List<Person> persons,MyPredicate<Person> predicate){
        List<Person> list = new ArrayList<Person>();
        for (Person person:persons) {
            if(predicate.test(person)){
                list.add(person);
            }
        }
        return list;
    }

然后使用匿名内部类

年龄大于20的：

List<Person> result = filterPerson(persons, new MyPredicate<Person>() {
            @Override
            public Boolean test(Person o) {
                return o.getAge() > 20;
            }
        });
        for(Person person : result){
            System.out.println(person);
        }

工资大于2000的：

List<Person> result = filterPerson(persons, new MyPredicate<Person>() {
            @Override
            public Boolean test(Person o) {
                return o.getSalary() > 2000;
            }
        });
        for(Person person : result){
            System.out.println(person);
        }

这样来看还是有不少冗余代码的。

如果使用Lambda表达式，两句就可以解决

年龄大于20的：

List<Person> result = filterPerson(persons,(p) -> p.getAge() > 20);

result.forEach(System.out::println);

工资大于2000的：

List<Person> result = filterPerson(persons,(p) -> p.getSalary() > 2000);

result.forEach(System.out::println);

如果还觉得不够简洁

使用stream api

在只有实体类和集合的情况下，

年龄大于19的人：

persons.stream()

               .filter((p) -> p.getAge() > 19)

               .forEach(System.out::println);

取出所有年龄：

persons.stream()

    .map(Person::getAge)

    .forEach(System.out::println);

现在我们对Lambda有了基本的了解，就是对匿名内部类的一个简化书写方式。

下面来说一下Lambda的基础语法

Lambda表达式由Lambda符 -> 分成了左侧和右侧两部分，左侧是匿名内部类中需要实现的方法的参数，右侧是对方法的实现。

首先来试一个无参无返回值的接口方法实现，比如多线程中的Runnable接口，只有一个run方法，无参也没有返回值

不使用Lambda表达式的情况下：

Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello world");
            }
        };
        runnable.run();

使用Lambda表达式：

Runnable r = () -> System.out.println("Hello Lambda");

r.run();

上面两种方式的执行结果

再来试一个有参无返回值的接口方法

Consumer接口中的accept方法

表达式的左侧传参，如果只有一个参数，可以省略小括号

       Consumer c = x -> System.out.println(x);

       c.accept("有参无返回值");

执行结果就会输出传入的这句 "有参无返回值"

如果有多个参数，有返回值，并且Lambda体中有多条语句

Comparator<Integer> c = (x,y) -> {
            System.out.println(x);
            System.out.println(y);
            return Integer.compare(x,y);
        };
        System.out.println(c.compare(1,2));

如果有返回值的情况下Lambda体中只有一条语句，花括号和return都可以省略

上面这个例子可以改写成

       Comparator<Integer> c = (x,y) -> Integer.compare(x,y);

       System.out.println(c.compare(1,2));

Lambda表达式左侧的参数列表的数据类型可以省略不写，因为JVM会根据上下文推断出数据类型。

Lambda表达式需要函数式接口的支持，所谓的函数式接口就是只有一个抽象方法的接口。

我们可以使用@FunctionalInterface注解修饰接口来检查是否是函数式接口

java8中为我们提供了一些函数式接口，这里列举几个核心的

Consumer<T> ：消费型接口

抽象方法：void accept(T t);

Supplier<T> ：供给型接口

抽象方法：T get();

Function<T,R>：函数型接口

抽象方法：R apply(T t);

Predicate<T>：断言型接口

抽象方法：boolean test(T t);

还有上面例子中看到的Lambda表达式的第二种表现形式，叫做方法引用。

方法引用有三种格式，

第一种，实例对象::方法名

例：x -> System.out.println(x);

方法引用：System.out::println;

第二种，类名::静态方法

例：(x,y) -> Integer.compare(x,y);      //比较两个数值的大小

方法引用：Integer::compare;

第三种，类名::方法名

例：(x,y) -> x.equals(y);

方法引用：String::equals;

使用第三种格式的前提是，接口的第一个参数是方法的调用者，第二个参数是方法的实参

使用方法引用的前提是，Lambda体中调用方法的参数列表和返回值类型，要与函数式接口中抽象方法的参数列表和返回值类型保持一致

除了方法引用，还有构造器引用

使用供给型接口测试

Supplier<Person> s = () -> new Person();

构造器引用：Supplier<Person> s = Person::new;

此时默认调用的是无参构造，如果想调用有参构造

Function<String ,Person> fun = (x) -> new Person(x);

构造器引用：Function<String ,Person> fun = Person::new;

此时默认调用的就是第一参数的构造器，如果想要两个参数的构造器

BiFunction<String ,String ,Person> biFun = Person::new;

所以，构造器引用需要调用的构造器的参数列表与函数式接口中抽象方法的参数列表保持一致

还有一个数组引用

Function<Integer,String[]> fun = x -> new String[x];

String[] str = fun.apply(10);

数组引用：Function<Integer,String[]> fun = String[]::new;

String[] str = fun.apply(10);

这里的参数传几，数组的长度就是几