【Java8】Lambda表达式与Stream API

迈不过友情╰ 2022-05-15 00:16 190阅读 0赞

Java8与Java7最大的改变就是Lambda表达式和Stream API了。java8给我们开发提供了很多的便利，这些我们该了解。

# 一、Lambda优化了什么？ #

Lambda是一个匿名函数，一段可以传递的代码。  
我们来看下Lambda使用之前的代码，比较，感受用Lambda的简便：  
给定一个需求：获取员工年龄大于35岁的信息：

List<Employee> employees = Arrays.asList(
            new Employee("张三",18,2289),
            new Employee("李四",28,6245),
            new Employee("银六",38,3267),
            new Employee("金四",40,5223),
            new Employee("老王",20,3290)
    );

## 普通用法： ##

public List<Employee> filterEmployee(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if (emp.getAge()>= 35){
                emps.add(emp);
            }
        }
        return emps;
    }

## 优化方式一：策略模式 ##

写两个接口：分别根据年龄查，根据工资查

public class FilterEmployeeByAge implements MyPredicate<Employee> { 
        @Override
        public boolean test(Employee employee) {
            return employee.getAge()>=35;
        }
    }

public class FilterEmployeeBySalary implements MyPredicate<Employee> { 
        @Override
        public boolean test(Employee employee) {
            return employee.getSalary()>=3240;
        }
    }

写一个过滤方法：

public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee employee:list){
            if (mp.test(employee)){
                emps.add(employee);
            }
        }
        return emps;
    }

test测试：

/* 优化方式一-策略设计模式 根据不同条件过滤员工信息，每个都要调用一个接口 */
    @Test
    public void test(){
        List<Employee> list = filterEmployee(employees,new FilterEmployeeByAge());
        for (Employee employee : list){
            System.out.println(employee);
        }
    
        System.out.println("-------------");
    
        List<Employee> list1 = filterEmployee(employees,new FilterEmployeeBySalary());
        for (Employee employee : list1){
            System.out.println(employee);
        }
    
    }

## 优化方式二：匿名内部类 ##

/* 核心代码只有一句，却多写了好几句 */
    @Test
    public void test4(){
        List<Employee> list = filterEmployee(employees, new MyPredicate<Employee>() {
           @Override
           public boolean test(Employee employee) {
               //核心代码
               return employee.getSalary()<=3400;
           }
       });
    
       for (Employee employee : list){
           System.out.println(employee);
       }
    }

## 优化方式三：Lambda表达式 ##

/*
        只写一句即可
     */
    @Test
    public void test2(){
        List<Employee> list = filterEmployee(employees,(e) -> e.getSalary() >= 3246); list.forEach(System.out::println); }

还不够简单？？？

## 优化方式四：Stream API ##

@Test
    public void test3(){
        employees.stream()
                .filter((e) -> e.getSalary() >= 3270) .limit(2) .forEach(System.out::println); //可以用双冒号，引用的方式 employees.stream() .map(Employee::getName) .forEach(System.out::println); }

怎么样，简单多了吧，代码很简洁，看的清楚明白。

好了，我们学习一下Lambda表达式和Stream API。

# Lambda表达式和Stream API #

## Lambda表达式简单用法： ##

/* * Lambda使用规则： * 左右遇一括号省 * 左侧推断类型省 * 横批：能省则省 */
    @Test
    public void test2(){
        //一个参数
        Consumer<String> con = x -> System.out.println(x);
        con.accept("hello");
        //两个参数
        Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
    }

## Stream API的用法： ##

Stream的步骤：创建Stream->过滤、映射等中间操作->终止操作。  
中间操作有：  
![这里写图片描述][70]  
有关用法，请到github上fork代码：

# Java8内置函数式接口，两种引用： #

![这里写图片描述][70 1]

内置接口：

@Test
    public void test1(){
        //通过collection系列集合提供的stream()或parallelStream()
        List<String> stringList = new ArrayList<>();
        Stream<String> stream1 = stringList.stream();
    
        //通过Arrays的静态方法stream()获取数组流
        Employee[] emps = new Employee[10];
        Stream<Employee> stream2 = Arrays.stream(emps);
    
        //Stream类中静态方法of()
        Stream<String> stream3 = Stream.of("aa","bb","cc");
    
        //4.创建无限流
        //迭代
        Stream<Integer> stream4 = Stream.iterate(0,(x)->x+2); stream4.limit(10).forEach(System.out::println); //生成随机 Stream.generate(()->Math.random()) .limit(5) .forEach(System.out::println); }

引用用法：

//构造器引用
    @Test
    public void  test5(){
        Supplier<Employee> sup = () -> new Employee();
    
        Supplier<Employee> sup2 = Employee::new;
        Employee emp = sup2.get();
    }
    
    @Test
    public void test6(){
        Function<Integer,Employee> fun = (x)->new Employee(x);
    
        Function<Integer,Employee> fun2 = Employee::new;
        Employee emp = fun2.apply(101);
    
        BiFunction<Integer,Integer,Employee> bf = Employee::new;
    }
    
    //方法引用
    /* 对象::实例方法 */
    @Test
    public void test2(){
        Employee ee = new Employee();
        Supplier<String> sup = () -> ee.getName();
        String str = sup.get();
        System.out.println(str);
        //简写如下
        Supplier<Integer> sup1 = ee::getAge;
        Integer num = sup1.get();
        System.out.println(num);
    }
    
    /* 类::静态方法 */
    @Test
    public void test3(){
        Comparator<Integer> com = (x,y) ->Integer.compare(x,y);
        //简写如下
        Comparator<Integer> com1 = Integer::compare;
    }
    
    @Test
    public void test4(){
        BiPredicate<String,String> bp = (x,y)->x.equals(y);
        //x调用y才可以这么写
        BiPredicate<String,String> bp2 = String::equals;
    }

对java8中Lambda和Stream API大概这样了解，熟悉掌握，开发效率大大提升，您也用起来吧！

**有关fork/join，下篇博客，我们继续，欢迎来访！**

**感谢您阅读我的博客！**

[70]: /images/20220515/c6f87bc37fa348dfbcda47e9ce52de88.png
[70 1]: /images/20220515/0425d739c1f5472391709cef3bea1ac4.png