Java详细分析Lambda表达式与Stream流的使用方法

2024-04-02 19:04:59 914人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录LambdaStream流 Lambda Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解

Lambda

Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁，更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。

我们可以知道, Lambda表达式是为简化语法而存在的

ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.sort(new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
});
System.out.println(list);

这里有一个List集合 , 并添加了一些元素, 我们想对他进行排序, 并且按照降序的方式来排 , 在没接触Lambda表达式之前 ,我们是向上面那样去做的

上面这种方式是匿名内部类写法 , 调用sort()方法时, 要求传入一个比较器, Comparator是一个接口, 接口可以new吗? 肯定是不能的 , 所以这里是有一个隐藏的类去实现了Comparator接口, 并且重写了它里面的compare()方法 , 来制定我们的比较规则, 这个隐藏的类没有类名, 就是我们这里所说的匿名内部类 , 但方法也是不能作为参数去传递的, 所以我们new了这个匿名内部类的对象 , 包裹了实现后的方法

但是现在我们嫌这个写法太啰嗦了 ,我们使用Lambda来看看

// Lambda表达式
list.sort((o1,o2) -> {return o2.compareTo(o1);});

这就和上面的匿名内部类写法是一样的

Lambda表达式的结构 :

左侧：lambda 表达式的参数列表

右侧：lambda 表达式中需要执行的功能，即 lambda 体

(arg1, arg2...) -> { body }

(type1 arg1, type2 arg2...) -> { body }

常见例子

无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略 () -> System.out.println("Hello World");

无参数，有返回值 () -> { return 3.1415 };

有参数，无返回值 (String s) -> { System.out.println(s); }

有一个参数，无返回值 s -> { System.out.println(s); }

有多个参数，有返回值 (int a, int b) -> { return a + b; }

有多个参数，表达式参数类型可以不写，JVM 可以根据上下文进行类型推断 (a, b) -> { return a - b; }

功能接口

功能接口上面一般会有这样一个注解标签@FunctionalInterface , 它表示此接口只有一个抽象方法, 当你注释的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误

例如 : 我们刚使用的comparator接口就有这样的注解

Stream流

允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。

流更偏向于数据处理和计算，比如 filter、map、find、sort 等。简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

我们常常将Stream流与Lambda表达式结合来编码 , 那么如何来使用呢 ?

这里分为 3 步 :

1. 获得流

2. 中间操作

3. 终端操作

中间操作(往往对数据进行筛选)

filter：过滤流中的某些元素,
sorted(): 自然排序，流中元素需实现 Comparable 接口
distinct: 去除重复元素
limit(n): 获取 n 个元素
skip(n): 跳过 n 元素，配合 limit(n)可实现分页
map(): 将其映射成一个新的元素

终端操作(往往对结果集进行处理)

forEach: 遍历流中的元素
toArray:将流中的元素倒入一个数组
Min:返回流中元素最小值 Max:返回流中元素最大值
count:返回流中元素的总个数
Reduce:所有元素求和
anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回
falseallMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false
findFirst：返回流中第一个元素
collect:将流中的元素倒入一个集合,Collection 或 Map

Integer[] arr = new Integer[]{1,4,3,2,5,5};
Arrays.stream(arr)    //拿到流
    .filter((a) -> {return a>3;})  //中间操作,过滤
    .forEach((a) -> {   //终端操作,遍历
        System.out.println(a);
    });
Integer[] arr = new Integer[]{1,4,3,2,5,5};
Object[] objects = Arrays.stream(arr)
    .sorted().distinct() //排序并去重
    .toArray();  //转数组
System.out.println(Arrays.toString(objects));
Integer[] arr = new Integer[]{1,4,3,2,5,5};
Integer max = Arrays.stream(arr).distinct()
    .max(((o1, o2) -> {    //去重返回最大值
        return o1 - o2;
    })).get();  //拿到这个值
//此处max为终端操作,返回的已经不是流,而是一个OPtion的对象
//它里面有一个get()方法可以返回这个值
System.out.println(max);
Integer[] arr = new Integer[]{1,4,3,2,5,5};
long count = Arrays.stream(arr).distinct()
    .count();   //返回总个数
System.out.println(count);
Integer[] arr = new Integer[]{1,4,3,2,5,5};
Integer i = Arrays.stream(arr).distinct()
    .reduce((o1, o2) -> {  //所有元素求和
        return o1 + o2;
    })
    .get();
System.out.println(i);

这里需要注意的是中间操作的map()方法和终端操作的collect()方法

设计一个Apple类

public class Apple {
    private Integer num;
    private String name;
    private String color;
}

并给出构造 , set 和 get 方法 ,此处由于篇幅原因省略

List<Apple> list = new ArrayList<>();
list.add(new Apple(100,"苹果1","红色"));
list.add(new Apple(105,"苹果5","红色"));
list.add(new Apple(104,"苹果4","红色"));
list.add(new Apple(103,"苹果3","红色"));
list.add(new Apple(102,"苹果2","红色"));

往一个list添加5个元素

List<String> collect = list.stream()
    //将属性的一列通过get方法映射成流
    .map(Apple::getName)
    //转为一个list集合
    .collect(Collectors.toList());
System.out.println(collect);
List<Apple> collect = list.stream().sorted(((o1, o2) -> {
    //通过num属性自定义排序
    return o1.getNum() - o2.getNum();
    }))
    //转为一个list集合
    .collect(Collectors.toList());
System.out.println(collect);
Map<Integer, String> map = list.stream().sorted(((o1, o2) -> {
    return o1.getNum() - o2.getNum();
    }))
    //转map, 第一个参数为键,第二个参数为值
    .collect(Collectors.toMap(Apple::getNum, Apple::getName));
System.out.println(map);

到此关于Lambda表达式与Stream流就介绍完了,感谢阅读

到此这篇关于Java详细分析Lambda表达式与Stream流的使用方法的文章就介绍到这了,更多相关Java Lambda与Stream内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java详细分析Lambda表达式与Stream流的使用方法

本文链接: https://www.lsjlt.com/news/147489.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341