JDK 8 新特性

1. Lambda表达式
2. Stream函数式操作流元素集合
3. 接口新增：默认方法与静态方法
4. 方法引用：与Lambda表达式联合使用
5. 引入重复注解
6. 类型注解
7. 最新的Date/Time API (JSR 310)
8. 新增base64加解密API
9. 数组并行（parallel）操作
10. JVM的PermGen空间被移除：取代它的是Metaspace（JEP 122）

一、Lambda表达式

Lambda演变过程

public class Student {

    public Student(String name, String sex, int salary, int age, String star) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.age = age;
        this.star = star;
    }

    //名字
    private String name;
    //性别
    private String sex;
    //薪水
    private int salary;
    //年龄
    private int age;
    //星座
    private String star;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getStar() {
        return star;
    }

    public void setStar(String star) {
        this.star = star;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", salary=" + salary +
                ", age=" + age +
                ", star='" + star + '\'' +
                '}';
    }
}

普通筛选

将这个集合遍历，然后依次的判断，这是最为普通的一种方式。

@Test
public void test1() {
	//首先创建一个
	List<Student> list = Arrays.asList(
			new Student("九天", "男", 5000, 18, "天秤座"),
			new Student("十夜", "男", 4000, 16, "双鱼座"),
			new Student("十一郎", "男", 3000, 24, "水瓶座")
	);

	List<Student> result = new ArrayList<>();
	for (Student student : list) {
		if ("天秤座".equals(student.getStar())) {
			result.add(student);
		}
	}
	System.out.println(result);
}

匿名内部类筛选

 通过匿名内部类的方法，在内部类中添加判断条件进行筛选,首先创建一个公共接口：

public interface FilterProcess<T> {
    boolean process(T t);
}

接下来通过一个公共函数，对集合以及筛选条件做一个共同方法，筛选到班级里星座是天秤星座的学生：

public List<Student> filterStudent(List<Student> students, FilterProcess<Student> mp){
    List<Student> list = new ArrayList<>();

    for (Student student : students) {
        if(mp.process(student)){
            list.add(student);
        }
    }
    return list;
}

最后是通过匿名内部类和该方法得到结果：

@Test
public void test2(){
    List<Student> students = Arrays.asList(
            new Student("九天","男",5000,18,"天秤座"),
            new Student("十夜","男",4000,16,"双鱼座"),
            new Student("十一郎","男",3000,24,"水瓶座")
    );

    List<Student> list = filterStudent(students, new FilterProcess<Student>() {
        @Override
        public boolean process(Student student) {
            return student.getStar().equals("天秤座");
        }
    });
    for (Student student : list) {
        System.out.println(student);
    }
}

半Lambda方法

但是通过这两种代码都是很多，所以java8在这一点上提供了对集合筛选最大程度的删减代码，就是第三种方法。第三种方法：通过Lambda直接判断，一步到位，不需要在写其他的方法。

@Test
public void test3(){
    List<Student> list = Arrays.asList(
            new Student("九天","男",5000,18,"天秤座"),
            new Student("十夜","男",4000,16,"双鱼座"),
            new Student("十一郎","男",3000,24,"水瓶座")
    );
    List<Student> result = filterStudent(list,(e)->e.getStar().equals("天秤座"));
    System.out.println(result);
}

 但是现在又会有人会问这个问题，我的那个方法中是这样子的

filterStudent(List<Student> students, FilterProcess<Student> mp)

为什么我的代码参数却是这样子的呢？

filterStudent(list,(e)->e.getStar().equals("天秤座")

其实 -> 这个是一个连接符，左边代表参数，而右边代表函数体（也就是我们说的条件），这个e就是代表  FilterProcess<Student> mp 这个参数的，只不过我们得在ava8 中lambda可以给这个参数附加上了条件，这些条件筛选都是封装到jdk8中内部类中自己实现的，所以我们只要附加条件就可以了，那个(e)就代表传了参数。