JDK8新特性、lambda

lambda表达式

• 是一种函数式接口(一个接口中只有一个抽象方法)的写法，可以简化函数式接口的代码书写量。

• 类似于Comparator就是函数式接口里面只有一个compare抽象方法。

传统方式创建一个储存自定义的Student类的TreeSet集合需要通过匿名内部类的方式重写Comparator中的compare方法。

public class Test {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            //按年龄排序
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        });
    }
}

用lambda表达式完成上述代码相同功能

import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>((x, y) -> Integer.compare(x.getAge(), y.getAge()));
        ts.add(new Student("张三", 18));
        ts.add(new Student("李四", 12));
        ts.add(new Student("王五", 21));
        ts.add(new Student("赵六", 17));
        for (Student s : ts) {
            System.out.println(s.toString());
        }
    }
}
/*Student [name=李四, age=12]
Student [name=赵六, age=17]
Student [name=张三, age=18]
Student [name=王五, age=21]*/

lambda表达式相当于简化了匿名内部类的方式：

(x, y) -> Integer.compare(x.getAge(), y.getAge())

这段代码就相当于下面的代码：

new Comparator<Student>() {
            //按年龄排序
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        }

直接给出参数，用括号括起来 (参数1，参数2)然后加上箭头->后面写匿名内部类中的条件语句。

案例：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//需求：过滤掉18岁以下的学生
//自定义一个过滤规则接口
interface MyPredicate<T> {
    // 定义一个抽象的过滤规则的方法
    public boolean test(T t);
}

public class Test {
    // 定义一个过滤的方法
    /**
     * @param list 需要被过滤的集合
     * @param m 过滤的规则
     * @return 过滤后的集合
     */
    public static List<Student> filterStudent(List<Student> list, MyPredicate<Student> mp) {
        // 定义最终返回结果
        List<Student> emps = new ArrayList<Student>();
        // 遍历参数中传入的d集合
        for (Student st : list) {
            //用过滤规则接口对象调用过滤方法
            if (mp.test(st)) {
                //如果过滤方法返回值是true则将元素添加到新集合中
                emps.add(st);
            }
        }
        //返回新集合
        return emps;
    }

    // 测试
    public static void main(String[] args) {
        // 通过Arrays工具类中的asList方法创建多个Student对象
        List<Student> list = Arrays.asList(
                new Student("张三", 18), 
                new Student("李四", 12), 
                new Student("王五", 21),
                new Student("赵六", 17));
        // 调用过滤的方法
        list = filterStudent(list, new MyPredicate<Student>() {
            //传统方法通过重写规则接口中的方法来过滤数据
            @Override
            public boolean test(Student t) {
                return t.getAge() >= 18;
            }
        });
        //遍历
        for (Student s : list) {
            System.out.println(s.toString());
        }
    }
}
/*
Student [name=张三, age=18]
Student [name=王五, age=21]
*/

使用lambda表达式写法如下：

list = filterStudent(list, (s) ->s.getAge()>=18);

括号中的参数s相当于是传统方法中的匿名对象，在箭头后面的表达式中直接写判断语句即可。