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

头像
Zeran
    阅读 7 分钟

    什么是lambda表达式

    在聊起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 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);
}

    Lambda表达式常用方法

    1. forEach 遍历集合中的元素
    List<String> fruits= Arrays.asList("apple", "orange", "banana");
fruits.forEach(fruit->{
           System.out.println("水果："+fruit);
      });

    image
    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));
        //获取这三个人的所有名字
        Set<String> set = list.stream().map(User::getName).collect(Collectors.toSet());
        //遍历所有人的名字
        set.forEach(name->{
            System.out.println("不重复的名字："+name);
        });
    }
}

    image
    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);
        });
    }
}

    image

    1. 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));![image](/img/bVcNopH)
        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);
    }
}

    image
    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);
    }
}

    image
    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);
        });
    }

    image
    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());
        });
    }

    image

    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);

    写到最后

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

    来自微信公众号 “eclipse编程”

    lambdajavajava-webjava8ssm
    本文系转载，阅读原文
    https://mp.weixin.qq.com/s/KiogwUQmivBjfVa2PQHblQ
    Zeran
    32 声望4 粉丝

    学而不思则罔，思而不学则殆。

    « 上一篇
    Java中字符流和字节流读写
    下一篇 »
    SpringBoot全局异常处理机制

    引用和评论

    推荐阅读
    头像
    Java线程的生命周期状态

    Zeran阅读 959

    头像
    在Java程序中监听mysql的binlog

    huan1993赞 7阅读 1k

    头像
    Activiti7实战笔记

    Corwien赞 4阅读 11k

    头像
    Just for fun——迅速写完快速排序

    ufdf赞 3阅读 2.3k

    头像
    Java自定义注解实现简单的权限认证

    kexb赞 5阅读 829

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 3阅读 1k

    头像
    Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

    程序员小富赞 5阅读 752

    0 条评论
    得票最新