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

时间  2021-08-12
标签 web 数据库 express 编程 微信 app eclipse ide 函数 栏目 HTML 繁體版
原文   原文链接

什么是lambda表达式

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

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流express

Java8中的stream 是对集合功能的加强，它专一于对集合进行各类很是便利、高效的聚合操做,或者大批量数据操做。编程

3. map()微信

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

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() 去重eclipse

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用法ide

allMatch()：检查是否匹配全部元素函数

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

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编程”

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程