【Java8新特性】让你想象不到代码前所未有的简单化编程（lambda表达式、函数式接口、方法引用、Stream API概论以及案例详解）

所有知识体系文章，GitHub已收录，欢迎Star！再次感谢，愿你早日进入大厂！

GitHub地址： https://github.com/Ziphtracks/JavaLearningmanual

搜索关注微信公众号“码出Offer”，送你学习福利资源！

Java8新特性让你的代码更加简单化！

---

目录

---

一、Lambda表达式
二、使用Lambda的注意事项
三、函数式接口
四、方法引用
五、Stream API
六、Stream API应用

---

一、Lambda表达式

• 概念： 允许把函数作为一个方法的参数（函数作为参数传递到方法中）

	<函数式接口> <变量名> = (参数1, 参数2...) -> {
   
		//方法体
	}

Lambda表达式使用方式

public class TestLambdas {
   
    public static void main(String[] args) {
   
        /*匿名内部类会生成.class文件*/
        Thread thread = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println("子线程启动");
            }
        });
        thread.start();

        /*lambda表达式简写（省略了内部类run方法）*/
        Runnable task = () -> {
   
            System.out.println("我才是第一个子线程");
        };
        Thread thread1 = new Thread(task);
        thread1.start();

        /*lambda再次简写（省略了对象接收并启动线程）*/
        new Thread(() -> {
   
            System.out.println("我是第二个子线程");
        }).start();

        /*lambdas最简写版（省略了{}）*/
        new Thread(() -> System.out.println("我是第三个子线程")).start();
    }
}

---

二、使用Lambda的注意事项

• 新的操作符 -> （箭头操作符）
  • (参数1, 参数2) -> 表示参数列表
  • -> { } 方法体
• 形参列表的数据类型会自动推断
• 如果形参列表为空，只需保留()
• 如果形参只有一个，()可以省略，只要参数名字即可
• 如果执行语句只有1句，且无返回值，{}可以省略
• 若有返回值，仍想省略{}，return也省略。保证执行语句只有1句
• Lamdba表达式不会生成单独的内部类文件
• lambda访问局部变量时，变量要修饰final，如果没有加，会自动添加

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

public class TestEmployee {
   
    public static void main(String[] args) {
   
        List<Employee> list = new ArrayList<Employee>();
        list.add(new Employee("Sendy", 19, 2500));
        list.add(new Employee("Jack", 20, 5000));
        list.add(new Employee("Mary", 18, 35000));
        list.add(new Employee("Join", 25, 50000));
        list.add(new Employee("Ziph", 22, 120000));

        System.out.println("---------------------------------获取员工年龄大于20岁的员工信息------------------------------------");

        /**
         * 获取员工年龄大于20岁的员工信息
         *
         * 打印结果：
         * Employee{name='Jack', age=20, salary=5000.0}
         * Employee{name='Join', age=25, salary=50000.0}
         * Employee{name='Ziph', age=22, salary=120000.0}
         */
        List<Employee> ageList = getAgeEmployee(list);
        for (Employee e : ageList) {
   
            System.out.println(e);
        }

        /**
         * 利用lambda写法传入规则来获取员工年龄大约20岁的员工信息
         */
        List<Employee> ageList1 = getAgeAndSalary(list, e -> e.getAge() >= 20);
        for (Employee e : ageList1) {
   
            System.out.println(e);
        }

        System.out.println("---------------------------------获取员工工资大于10000元的员工信息------------------------------------");

        /**
         * 获取员工工资大于10000元的员工信息
         *
         * 打印结果：
         * Employee{name='Mary', age=18, salary=35000.0}
         * Employee{name='Join', age=25, salary=50000.0}
         * Employee{name='Ziph', age=22, salary=120000.0}
         */
        List<Employee> salaryList = getSalaryEmployee(list);
        for (Employee e : salaryList) {
   
            System.out.println(e);
        }

        /**
         * 利用lambda写法传入规则来获取员工工资大于10000元的员工信息
         */
        List<Employee> salaryList1 = getAgeAndSalary(list, e -> e.getSalary() >= 10000);
        for (Employee e : salaryList1) {
   
            System.out.println(e);
        }

        System.out.println("---------------------------------获取员工年龄大于20岁并且工资大于10000元的员工信息------------------------------------");

        /**
         * 利用lambda写法传入规则来获取员工年龄大于20岁并且工资大于10000元的员工信息
         *
         * 打印结果：
         * Employee{name='Join', age=25, salary=50000.0}
         * Employee{name='Ziph', age=22, salary=120000.0}
         */
        List<Employee> ageAndSalaryList = getAgeAndSalary(list, e -> e.getSalary() >= 10000 && e.getAge() >= 20);
        for (Employee e : ageAndSalaryList) {
   
            System.out.println(e);
        }

        /**
         * 利用Stream API过滤，传入规则来获取员工年龄大于20岁并且工资大于10000元的员工信息
         * 注意：也可以把(e)的括号省略掉
         */
        list.stream().filter((e) -> e.getSalary() >= 10000 && e.getAge() >= 20).forEach(System.out::println);
    }

    /**
     * 利用函数式接口来制定规则创建方法
     *
     * @param list
     * @param predicate 需要传入规则（lambda）
     * @return
     */
    public static List<Employee> getAgeAndSalary(List<Employee> list, MyPredicate<Employee> predicate) {
   
        List<Employee> newList = new ArrayList<>();
        for (Employee e : list) {
   
            /*调用规则！只使用规则，不用关心过程！*/
            if (predicate.test(e)) {
   
                newList.add(e);
            }
        }
        return newList;
    }

    /**
     * 返回员工年龄大于等于20岁的员工信息的方法
     *
     * @param list
     * @return
     */
    public static List<Employee> getAgeEmployee(List<Employee> list) {
   
        List<Employee> newList = new ArrayList<>();

        for (Employee e : list) {
   
            if (e.getAge() >= 20) {
   
                newList.add(e);
            }
        }
        return newList;
    }

    /**
     * 返回员工工资大于10000元的员工信息的方法
     *
     * @param list
     * @return
     */
    public static List<Employee> getSalaryEmployee(List<Employee> list) {
   
        List<Employee> newList = new ArrayList<>();

        for (Employee e : list) {
   
            if (e.getSalary() >= 10000) {
   
                newList.add(e);
            }
        }
        return newList;
    }
}

/**
 * 规则
 * 能力
 * @param <T>
 */
public interface MyPredicate<T> {
   
    boolean test(T t);
}

/**
 * 员工类
 */
class Employee {
   
    private String name;
    private int age;
    private double salary;

    public Employee() {
   
    }

    /**
     * @param name      姓名
     * @param age       年龄
     * @param salary    工资
     */
    public Employee(String name, int age, double salary) {
   
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
   
        return name;