01.什么是 lambda 表达式

1. 函数式接口

在聊起 lambda 表达式之前，我们不得不提起函数式接口：一个接口只包含唯一的方法，那么它就是函数式接口。例如：

public class LambdaTest {

    public static void main(String[] args) {

        Lambda lambda=new SonLambda();

        lambda.say();

    }

}

//1.一个接口只包含一个方法就是函数式接口

interface Lambda {

    void say();

}

//2.一个类实现接口，要重写这个接口的所有方法

class SonLambda implements Lambda {

    @Override

    public void say() {

        System.out.println("i love lambda");

    }

}

有时候太懒的话我们会直接写一个匿名内部类。

public class LambdaTest {

    public static void main(String[] args) {

        //2.匿名内部类: 没有子类，必须借助接口或者父类

        Lambda lambda=new Lambda() {

            @Override

            public void say() {

                System.out.println("i like lambda");

            }

        };

        lambda.say();

    }

}

//1.一个接口只包含一个方法就是函数式接口

interface Lambda {

    void say();

}

但是我们写代码肯定是越懒(简单)越好，这个时候 Lambda 表达式闪亮登场。

Lambda表达式是 Java8 发布的最重要的新特性，它的出现就是为了解决匿名内部类那一坨坨代码的问题，让代码看起来更简洁。

lambda 表达式的语法格式如下：

(parameters) -> expression

或者

(parameters) ->{ statements;}

parameters 是参数，expression 是表达式。

对于上面例子中的匿名内部类，我们用 Lambda 表达式该怎样表示呢？

因为上面例子中匿名内部类只有一个方法，所以我们可以省略掉它的接口名和方法名。

又因为没有参数，所以我们直接可以用一个中括号表示它的方法名，然后用->指向它的方法体。如下所示：() -> {}替代了匿名内部类。

public class LambdaTest {

    public static void main(String[] args) {

        Lambda lambda=()->{

            System.out.println("i like lombda");

        };

        lambda.say();

    }

}

//1.一个接口只包含一个方法就是函数式接口

interface Lambda {

    void say();

}

那么你可能会问，带有参数的接口用 lambda 表达式该怎样表示呢？

如下所示：

public class LambdaTest {

    public static void main(String[] args) {

        Lambda lambda=(a,b)->{

            System.out.println("a="+a+" b="+b);

        };

        lambda.say(1,2);

    }

}

//1 一个接口只包含一个方法就是函数式接口

interface Lambda {

    void say(int a,int b);

}

02.Lambda 表达式常用方法

1. forEach 遍历集合中的元素

List<String> fruits= Arrays.asList("apple", "orange", "banana");

fruits.forEach(fruit->{

           System.out.println("水果："+fruit);

      });

2. stream流

Java8中的 stream 是对集合功能的增强，它专注于对集合进行各种非常便利、高效的聚合操作,或者大批量数据操作。

3. map()

获取集合中的某一个元素，返回新的集合。记住使用map之前首先要获得集合的 stream 流。

public class LambdaTest {

    public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌",25));

        list.add(new User(2,"赵敏",24));

        list.add(new User(3,"周芷若",23));

        //获取这三个人的所有名字

        List<String> nameList = list.stream().map(User::getName).collect(Collectors.toList());

        //遍历所有人的名字

        nameList.forEach(name->{

            System.out.println("名字："+name);

        });

    }

}

4. collect(Collector c)

将操作之后的结果转换为集合，Collector 除了可以转为list集合，还能转为set集合，也就是不重复的集合。

public class LambdaTest {

    public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌",25));

        list.add(new User(2,"张无忌",24));

        list.add(new User(3,"周芷若",23));

        //获取这三个人的所有名字

        Set<String> set = list.stream().map(User::getName).collect(Collectors.toSet());

        //遍历所有人的名字

        set.forEach(name->{

            System.out.println("不重复的名字："+name);

        });

    }

}

5. distinct() 去重

public class LambdaTest {

    public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌01",25));

        list.add(new User(2,"张无忌01",24));

        list.add(new User(3,"赵敏",23));

        //获取这三个人的所有名字

        List<String> nameList = list.stream().map(User::getName).distinct().collect(Collectors.toList());

        //遍历所有人的名字

        nameList.forEach(name->{

            System.out.println("去重之后的名字："+name);

        });

    }

}

6. reduce()

将元素中的值以某种方式连接起来，SQL中类似 sum()、avg() 或者 count() 的聚集函数，实际上就是 reduce 操作，因为它们接收多个值并返回一个值。

public class LambdaTest {

    public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌",25));

        list.add(new User(2,"周芷若",24));

        list.add(new User(3,"赵敏",23));

        //1.获取这三个人的年龄之和

        //2.map(w -> w.getAge()) 获取每一个人的年龄

        //3.reduce((x, y) -> x + y) 将他们的年龄相加

        //4.get() 获取最后的结果

        Integer sumAge = list.stream().map(w -> w.getAge()).reduce((x, y) -> x + y).get();

        System.out.println("这三个人的年龄之和："+sumAge);

    }

}

7. match用法

allMatch()：检查是否匹配所有元素

anyMatch(): 检查是否匹配任意元素

noneMatch(): 检查是否没有匹配元素

public class LambdaTest {

    public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌",25));

        list.add(new User(2,"周芷若",24));

        list.add(new User(3,"赵敏",23));

        boolean result01 = list.stream().allMatch(w->w.getAge()>23);

        boolean result02= list.stream().anyMatch(w->w.getAge()>23);

        boolean result03= list.stream().noneMatch(w->w.getAge()>23);

        System.out.println("所有人都大于23岁吗？："+result01);

        System.out.println("有大于23岁的吗？："+result02);

        System.out.println("他们没有大于23岁的吗？："+result03);

    }

}

8. filter() 条件过滤

public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌",25));

        list.add(new User(2,"周芷若",24));

        list.add(new User(3,"赵敏",23));

        //1.filter(w -> w.getAge() > 23) 年龄大于23

        //2.map(w -> w.getName()) 获取人的名字

        //3.获取这三个人中年龄大于23岁的人的名字的集合

        List<String> nameList = list.stream().filter(w -> w.getAge() > 23).map(w -> w.getName()).collect(Collectors.toList());

        nameList.forEach(name->{

            System.out.println("年龄大于23岁的人："+name);

        });

    }

9. sorted() 排序

public static void main(String[] args) {

        //新增三个人的信息

        ArrayList<User> list = new ArrayList<>();

        list.add(new User(1,"张无忌",25));

        list.add(new User(2,"周芷若",24));

        list.add(new User(3,"赵敏",23));

        //1.sorted(Comparator.comparing(User::getAge)) 根据某个字段排序

        //2.reversed() 从大到小排序

        List<User> users1 = list.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());

        System.out.println("-------------年龄从小到大排序");

        users1.forEach(user->{

            System.out.println(user.getName()+" "+user.getAge());

        });

        System.out.println("-------------年龄从大到小排序");

        List<User> users2 = list.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());

        users2.forEach(user->{

            System.out.println(user.getName()+" "+user.getAge());

        });

    }

03.Lambda表达式常见案例

案例一：获取所有用户的ID。

List<Integer> ids = list.stream().map(w -> w.getId()).collect(Collectors.toList());

案例二：将所有用户的 ID 作为 key , name 作为 value 放到一个map里面。

Map<Integer, String> userMap = list.stream().collect(Collectors.toMap(User::getId,User::getName));

案例三：使用 stream 转换为集合，我们再也不用一个个去add了。

List<User> users = Stream.of(user1, user2, user3).collect(Collectors.toList());

案例四：map 对象转换，我们一般从数据库查数据为 PO 对象，返回给web端时一般为 VO 对象，那么这其中就涉及对象转换返回，map 就提供了便利的操作。

List<UserVo> userVos = userList.stream().map(user -> {

    UserVo userVo = new UserVo();

    BeanUtils.copyProperties(user, userVo);

    return userVo;

}).collect(Collectors.toList());

案例五：按照某一个属性进行分组，比如这里我们按照用户性别进行分组。

Map<Integer, List<User>> genderGroup = userList.stream().collect(Collectors.groupingBy(User::getSex, Collectors.toList()));

案例六：求最小、最大、平均值、求和。

int min = userList.stream().mapToInt(User::getAge).min().orElse(-1);

int max = userList.stream().mapToInt(User::getAge).max().orElse(-1);

int sum = userList.stream().mapToInt(User::getAge).sum();

double average = userList.stream().mapToInt(User::getAge).average().orElse(-1);

04.写到最后

注意：lambda 表达式有个限制，那就是只能引用final或final局部变量，这就是说不能在lambda内部修改定义在域外的变量,不然会报错。

微信公众号：eclipse编程。专注于编程技术分享，坚持终身学习。

巴特西

学会lambda表达式，能让你少敲1000行代码！