java8 新特性-Lambda 表达式

来源：互联网发布：什么情况下多进程编程编辑：程序博客网时间：2024/05/02 04:16
最近在学习一些java8的新特性,觉得不错的就记载下来，以后查看 也方便，这边我直接以案例贴出来吧，好理解。
      以前我们做比较的时候一般是这样的：
     //原来的匿名内部类写法：
    @Test
    publicvoid test1(){
        Comparator<String> com =new Comparator<String>(){
            @Override
            publicint compare(String o1, String o2) {
                returnInteger.compare(o1.length(), o2.length());
            }
        };
         
        TreeSet<String> ts =new TreeSet<>(com);
         
        TreeSet<String> ts2 =new TreeSet<>(newComparator<String>(){
            @Override
            publicint compare(String o1, String o2) {
                returnInteger.compare(o1.length(), o2.length());
            }
             
        });
    }
 //现在的 Lambda 表达式：
 @Test    publicvoid test2(){
        Comparator<String> com =(x,y) ->Integer.campare(x.length(),y.length());
        TreeSet<String> ts =new TreeSet<>(com);
    }
下面我们来举一个工作中常遇到的问题：
  List<Employee> emps = Arrays.asList(
            newEmployee(101,"张三", 18,9999.99),
            newEmployee(102,"李四", 59,6666.66),
            newEmployee(103,"王五", 28,3333.33),
            newEmployee(104,"赵六", 8,7777.77),
            newEmployee(105,"田七", 38,5555.55)
    );
 
    //需求：获取公司中年龄小于 35 的员工信息
    publicList<Employee> filterEmployeeAge(List<Employee> emps){
        List<Employee> list =new ArrayList<>();
         
        for(Employee emp : emps) {
            if(emp.getAge() <=35){
                list.add(emp);
            }
        }
         
        returnlist;
    }
     
    @Test
    publicvoid test3(){
        List<Employee> list = filterEmployeeAge(emps);
         
        for(Employee employee : list) {
            System.out.println(employee);
        }
    }
     
    //需求：获取公司中工资大于 5000 的员工信息
    publicList<Employee> filterEmployeeSalary(List<Employee> emps){
        List<Employee> list =new ArrayList<>();
         
        for(Employee emp : emps) {
            if(emp.getSalary() >=5000){
                list.add(emp);
            }
        }
         
        returnlist;
    }
//优化方式一：策略设计模式    publicList<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
        List<Employee> list =new ArrayList<>();
         
        for(Employee employee : emps) {
            if(mp.test(employee)){
                list.add(employee);
            }
        }
         
        returnlist;
    }
     @Test    publicvoid test4(){
        List<Employee> list = filterEmployee(emps,new FilterEmployeeForAge());
        for(Employee employee : list) {
            System.out.println(employee);
        }
         
        System.out.println("------------------------------------------");
         
        List<Employee> list2 = filterEmployee(emps,new FilterEmployeeForSalary());
        for(Employee employee : list2) {
            System.out.println(employee);
        }
    }

 //优化方式二：匿名内部类    @Test
    publicvoid test5(){
        List<Employee> list = filterEmployee(emps,new MyPredicate<Employee>() {
            @Override
            publicboolean test(Employee t) {
                returnt.getId() <= 103;
            }
        });
         
        for(Employee employee : list) {
            System.out.println(employee);
        }
    }
 //优化方式三：Lambda 表达式    @Test
    publicvoid test6(){
        List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <=35);
        list.forEach(System.out::println);
         
        System.out.println("------------------------------------------");
         
        List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >=5000);
        list2.forEach(System.out::println);
    }

 //优化方式四：Stream API
    @Test
    publicvoid test7(){
        emps.stream()
            .filter((e) -> e.getAge() <=35)
            .forEach(System.out::println);
         
        System.out.println("----------------------------------------------");
         
        emps.stream()
            .map(Employee::getName)
            .limit(3)
            .sorted()
            .forEach(System.out::println);
    }

哈哈 最后优化的代码都快没了,越写越省事。。。。。。。
阅读全文
0 0