标签：初体验 List Employee employeeList employee println public 表达式 lambda

lambda表达式是一个匿名函数，我们可以将lambda表达式理解为一段可以传递的代码(将代码像数据一样传递)
可以写出更为简洁的代码


场景描述：
    创建一个对象集合，删选出符合要求的对象(1.删选出工资大于8000的  2.删除出年龄大于18的)
    对象集合如下：
        List<Employee> employees = Arrays.asList(
             new Employee("吴孟达", 18, 18000.0),
            new Employee("刘丹", 19, 10000.0),
            new Employee("赵四", 20, 5000.0),
            new Employee("王五", 25, 7000.0),
            new Employee("李六", 30, 8000.0)
        );
1.第一种方式（如果按照正常处理方法，会给每个筛选都创建一个方法，但是如果删选条件发生变化，就得创建一个新的方法，会造成方法的冗余 ）
示例代码如下：
    /**
     * 定义一个根据工资筛选员工的方法
     * @param employees:员工列表
     * @return 删选后的员工
     */
    public List<Employee> employeesFilterBySalary(List<Employee> employees){
        List<Employee> employeeList=new ArrayList<>();
        for (Employee employee : employees) {
            if (employee.getSalary()>8000)
                employeeList.add(employee);
        }
        return employeeList;
    }
    /*
        测试普通删选方式
     */
    @Test
    public void testEmployeeFilterBySalary(){
        List<Employee> employeeList = employeesFilterBySalary(employees);
        for (Employee employee : employeeList) {
            System.out.println(employee);
        }
    }
    如果更改了工资要大于6000时，得重新写个方法，这样虽然可以达到目的，但是造成了代码的冗余

2.第二种方式：采用一种设计模式，叫做策略模式，值得推荐
    2.1 先定义一个接口
        /*
            定义一个借口并设置泛型以传入到方法中
            定义的方法返回boolean值，该方法进行过滤，有不同的实现类实现该接口，从而达到不同的筛选效果
        */
        public interface EmployeeFilter<T> {
            public boolean employeeFilter(T t);
        }
    2.2 接口实现类1(根据工资进行删选：对于传入的员工对象，如果工资大于8000，返回true)
        public class EmployeeFilterBySalary implements EmployeeFilter<Employee> {
            @Override
            public boolean employeeFilter(Employee employee) {
                return employee.getSalary() > 8000 ? true : false;
            }
        }
    2.3 接口实现类2(根据年龄进行筛选)
        public class EmployeeFilterByAge implements EmployeeFilter<Employee> {
            @Override
            public boolean employeeFilter(Employee employee) {
        
                return employee.getAge() > 18 ? true : false;
            }
        }
    2.4 定义统一的筛选方法
        /*
            进行员工删选
         */
         重点1：传入员工列表，删选策略的接口(重要)
        public List<Employee> employeesFilter(List<Employee> list, EmployeeFilter<Employee> employeeFilter) {
            List<Employee> employeeList = new ArrayList<>();
            for (Employee employee : list) {
                if (employeeFilter.employeeFilter(employee))
                    employeeList.add(employee);
            }
            return employeeList;
        }
    2.5 测试
        /**
         * 改造1：使用策略模式进行改造
         */
        @Test
        public void test01() {
            System.out.println("删选出工资大于8000的");
            1.重点1:传入不同的接口实现类，即传入不同的筛选策略，达到不同的筛选效果
            List<Employee> employeeListFileterBySalary = employeesFilter(employees, new EmployeeFilterBySalary());
            for (Employee employee : employeeListFileterBySalary) {
                System.out.println(employee);
            }
            System.out.println("-------------------------");
            
            2.重点2:传入不同的接口实现类，即传入不同的筛选策略，达到不同的筛选效果
            System.out.println("删选出年龄大于18的");
            List<Employee> employeeListFilterByAge = employeesFilter(employees, new EmployeeFilterByAge());
            for (Employee employee : employeeListFilterByAge) {
                System.out.println(employee);
            }
        }

改造2：使用匿名内部类的形式：不需要定义接口实现类，而是在创建接口实例时直接重写接口的方法

    /*
        进行员工删选
     */
    public List<Employee> employeesFilter(List<Employee> list, EmployeeFilter<Employee> employeeFilter) {
        List<Employee> employeeList = new ArrayList<>();
        for (Employee employee : list) {
            if (employeeFilter.employeeFilter(employee))
                employeeList.add(employee);
        }
        return employeeList;
    }
    /*
        使用匿名内部类
     */
    @Test
    public void test02() {
        System.out.println("测试匿名内部类");
        重点1：创建接口实例，直接实现接口中的方法
        List<Employee> employeeList = employeesFilter(employees, new EmployeeFilter<Employee>() {
            @Override
            public boolean employeeFilter(Employee employee) {
                return employee.getSalary() > 8000 ? true : false;
            }
        });
        for (Employee employee : employeeList) {
            System.out.println(employee);
        }
    }
    

3.改造3：使用lambda表达式：
    /*
        进行员工删选
     */
    重点1：此处传参使用了泛型 ，这也是下面能使用(e) 的原因
    public List<Employee> employeesFilter(List<Employee> list, EmployeeFilter<Employee> employeeFilter) {
        List<Employee> employeeList = new ArrayList<>();
        for (Employee employee : list) {
            if (employeeFilter.employeeFilter(employee))
                employeeList.add(employee);
        }
        return employeeList;
    }
    /*
       优化3:使用lambda表达式
     */
    @Test
    public void testLambda() {
        System.out.println("删选出年龄大于18的");
        List<Employee> employeeListFilterByAge = employeesFilter(employees, (e) -> e.getAge() > 18);
        employeeListFilterByAge.forEach(System.out::println);
        System.out.println("-------------------------");
    
        System.out.println("删选出工资大于8000的");
        List<Employee> employeeListFilterBySalary = employeesFilter(employees, (e) -> e.getSalary() > 8000.0);
        employeeListFilterBySalary.forEach(System.out::println);
    }
    
4.使用Strem流：
    /*
    优化方法4：使用Stream流：发现其不需要实现接口，定义公共的筛选方法，直接像操作数据库一样直接进行筛选输出，nb 
     */
    @Test
    public void testByStream() {
        employees.stream()
                .filter((e) -> e.getSalary() > 8000)
                .forEach(System.out::println);
    }

标签：初体验,List,Employee,employeeList,employee,println,public,表达式,lambda
来源： https://www.cnblogs.com/wmd-l/p/16314804.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。