• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

快速掌握Java8 Stream函数式编程技巧

开发技术 开发技术 4天前 8次浏览

快速掌握Java8 Stream函数式编程技巧

函数式编程优势

  • “函数第一位”,即函数可以出现在任何地方。
  • 可以把函数作为参数传递给另一个函数,还可以将函数作为返回值。
  • 让代码的逻辑更清晰更优雅。
  • 减少了可变量(Immutable Variable)的声明,程序更为安全。
  • 支持惰性计算。

Lambda语法三部分

  • 一个括号内用逗号分隔的形式参数参数是函数式接口里面方法的参数
  • 一个箭头符号:->
  • 方法体,可以是表达式和代码块,方法体函数式接口里面方法的实现,如果是代码块,则必须用{}来包裹起来,且需要一个return 返回值,但有个例外,若函数式接口里面方法返回值是void,则无需{}。例如:
  • (parameters) -> expression 或者 (parameters) -> { statements; }

方法引用是lambda表达式的一个简化写法,所引用的方法其实是lambda表达式的方法体实现,语法也很简单,左边是容器(可以是类名,实例名),中间是“::”,右边是相应的方法名。如下所示:
ObjectReference::methodName

一般方法的引用格式是:

  • 如果是静态方法,则是ClassName::methodName。如 Object ::equals
  • 如果是实例方法,则是Instance::methodName。如Object obj=new Object();obj::equals;
  • 构造函数.则是ClassName::new

Stream是什么

Stream是Java8中新加入的api,更准确的说: Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利、高效的聚合操作,或者大批量数据操作 。Stream API 借助于同样新出现的 Lambda 表达式,极大的提高编程效率和程序可读性。

 快速掌握Java8 Stream函数式编程技巧

以前我们处理复杂的数据只能通过各种for循环,不仅不美观,而且时间长了以后可能自己都看不太明白以前的代码了,但有Stream以后,通过filter,map,limit等等方法就可以使代码更加简洁并且更加语义化。 Stream的效果就像上图展示的它可以先把数据变成符合要求的样子(map),吃掉不需要的东西(filter)然后得到需要的东西(collect)。

Stream操作分类

Stream上的所有操作分为两类:中间操作和结束操作,中间操作只是一种标记,只有结束操作才会触发实际计算。中间操作又可以分为无状态的(Stateless)和有状态的(Stateful),无状态中间操作是指元素的处理不受前面元素的影响,而有状态的中间操作必须等到所有元素处理之后才知道最终结果,比如排序是有状态操作,在读取所有元素之前并不能确定排序结果;结束操作又可以分为短路操作和非短路操作,短路操作是指不用处理全部元素就可以返回结果,比如找到第一个满足条件的元素。之所以要进行如此精细的划分,是因为底层对每一种情况的处理方式不同。

快速掌握Java8 Stream函数式编程技巧

Stream API等价实现

求出字符串集合中所有以字母A开头字符串的最大长度

int longest = 0;
for(String str : strings){
    if(str.startsWith("A")){// 1. filter(), 保留以A开头的字符串
        int len = str.length();// 2. mapToInt(), 转换成长度
        longest = Math.max(len, longest);// 3. max(), 保留最长的长度
    }
}

快速掌握Java8 Stream函数式编程技巧

int longest = strings.stream()
    .filter(str -> str.startsWith("A"))
    .mapToInt(str ->  str.length()) 
    //.mapToInt(String::length)
    .max();

Stream串行与并行

快速掌握Java8 Stream函数式编程技巧

Stream可以分为串行与并行两种,串行流和并行流差别就是单线程和多线程的执行。 default Stream stream() : 返回串行流 default Stream parallelStream() : 返回并行流 stream()和parallelStream()方法返回的都是java.util.stream.Stream<E>类型的对象,说明它们在功能的使用上是没差别的。唯一的差别就是单线程和多线程的执行。

Stream性能总结

1.对于简单操作,比如最简单的遍历,Stream串行API性能明显差于显示迭代,但并行的Stream API能够发挥多核特性。

2.对于复杂操作,Stream串行API性能可以和手动实现的效果匹敌,在并行执行时Stream API效果远超手动实现。

所以,如果出于性能考虑:

  • 对于简单操作推荐使用外部迭代手动实现。
  • 对于复杂操作,推荐使用Stream API。
  • 在多核情况下,推荐使用并行Stream API来发挥多核优势。
  • 单核情况下不建议使用并行Stream API。 如果出于代码简洁性考虑,使用Stream API能够写出更短的代码。即使是从性能方面说,尽可能的使用Stream API也另外一个优势,那就是只要Java Stream类库做了升级优化,代码不用做任何修改就能享受到升级带来的好处。

参考 Java 8 Stream的性能到底如何?

Stream 来源

快速掌握Java8 Stream函数式编程技巧

所有流计算都有一种共同的结构:它们具有一个流来源、0 或多个中间操作,以及一个终止操作。流的元素可以是对象引用 (Stream<String>),也可以是原始整数 (IntStream)、长整型 (LongStream) 或双精度 (DoubleStream)。

因为 Java 程序使用的大部分数据都已存储在集合中,所以许多流计算使用集合作为它们的来源。JDK 中的 Collection 实现都已增强,可充当高效的流来源。但是,还存在其他可能的流来源,比如数组、生成器函数或内置的工厂(比如数字范围),而且可以编写自定义的流适配器,以便可以将任意数据源充当流来源。如上图中一些流生成方法。

Stream 操作

中间操作负责将一个流转换为另一个流,中间操作包括 filter()(选择与条件匹配的元素)、map()(根据函数来转换元素)、distinct()(删除重复)、limit()(在特定大小处截断流)和 sorted()。一些操作(比如 mapToInt())获取一种类型的流并返回一种不同类型的流。

中间操作始终是惰性的:调用中间操作只会设置流管道的下一个阶段,不会启动任何操作。重建操作可进一步划分为无状态 和有状态 操作。无状态操作(比如 filter() 或 map())可独立处理每个元素,而有状态操作(比如 sorted() 或 distinct())可合并以前看到的影响其他元素处理的元素状态。

快速掌握Java8 Stream函数式编程技巧

数据集的处理在执行终止操作时开始,比如缩减(sum() 或 max())、应用 (forEach()) 或搜索 (findFirst()) 操作。终止操作会生成一个结果或副作用。执行终止操作时,会终止流管道,如果您想再次遍历同一个数据集,可以设置一个新的流管道。如下给出了一些终止流操作。

 快速掌握Java8 Stream函数式编程技巧

Stream 流与集合比较

集合是一种数据结构,它的主要关注点是在内存中组织数据,而且集合会在一段时间内持久存在。 流的关注点是计算,而不是数据。流没有为它们处理的元素提供存储空间,而且流的生命周期更像一个时间点 — 调用终止操作。 不同于集合,流也可以是无限的(Stream.generate、Stream.iterate);相应地,一些操作(limit()、findFirst())是短路,而且可在无限流上运行有限的计算。 程序 = 数据结构 + 算法,集合即数据结构,流操作相当于算法

快速掌握Java8 Stream函数式编程技巧

数据形式:集合是一个内存中的数据结构,它包含数据结构中目前所有的值——集合中的每个元素都得先算出来才能添加到集合中。(你可以往集合里加东西或者删东西,但是不管什么时候,集合中的每个元素都是放在内存里的,元素都得先算出来才能成为集合的一部分。) 相比之下,流则是在概念上固定的数据结构(你不能添加或删除元素),其元素则是按需计算的。

快速掌握Java8 Stream函数式编程技巧

迭代方式:使用Collection接口需要用户去做迭代(比如用for-each),这称为外部迭代。相反,Streams库使用内部迭代——它帮你把迭代做了,还把得到的流值存在了某个地方,你只要给出一个函数说要干什么就可以了。Steams库的内部迭代可以自动选择一种适合你硬件的数据表示和并行实现。

Stream 基本使用

filter筛选(中间操作)

输出:4,5

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);

Stream<Integer> stream = integerList.stream().filter(i -> i > 3);

distinct去重(中间操作)

输出:1,2,3,4,5

List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);

Stream<Integer> stream = integerList.stream().distinct();

limit限制(中间操作)

输出:1,1,2

 List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);

 Stream<Integer> stream = integerList.stream().limit(3);

skip跳过(中间操作)

输出:2,3,4,5

 List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);

 Stream<Integer> stream = integerList.stream().skip(2);

map流映射(中间操作)

输出:6, 7, 2, 6

List<String> stringList = Arrays.asList("Java 8", "Lambdas",  "In", "Action");

Stream<Integer> stream = stringList.stream().map(String::length);

flatMap流转换(中间操作)

输出:1, 2, 3, 4

将一个流中的每个值都转换为另一个流

List<List<Integer>> lists = new ArrayList<List<Integer>>() {{
    add(Arrays.asList(1, 2));
    add(Arrays.asList(3, 4));
}};

Stream<Integer> stream = lists.stream().flatMap(List::stream);

//Stream<Integer> stream = lists.stream().flatMap(list -> list.stream());

allMatch匹配所有(中间操作)

输出:

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);

if (integerList.stream().allMatch(i -> i > 3)) {
    System.out.println("值都大于3");
}

noneMatch全部不匹配(中间操作)

输出:

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);

if (integerList.stream().noneMatch(i -> i > 3)) {
    System.out.println("值都小于3");
}

anyMatch匹配其中一个(中间操作)

输出:存在大于3的值

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
if (integerList.stream().anyMatch(i -> i > 3)) {
    System.out.println("存在大于3的值");
}

findFirst查找第一个(终端操作)

输出:4

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = integerList.stream().filter(i -> i > 3).findFirst();

findAny随机查找一个(终端操作)

输出:存在大于3的值

和findFirst操作相比,并行流优势更大

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
if (integerList.stream().findAny(i -> i > 3)) {
    System.out.println("存在大于3的值");
}

Stream 常用统计

List<Integer> ints = Arrays.asList(1, 1, 2, 2, 3);
//统计流中元素个数
ints.stream().count();
ints.stream().collect(Collectors.counting());

//获取流中最小值
ints.stream().min(Integer::compareTo);
ints.stream().collect(Collectors.minBy(Integer::compareTo));

//获取流中最大值
ints.stream().max(Integer::compareTo);
ints.stream().collect(Collectors.maxBy(Integer::compareTo));

//求和
ints.stream().mapToInt(Integer::intValue).sum();
ints.stream().collect(Collectors.summingInt(Integer::intValue));
ints.stream().reduce(0, Integer::sum);

//平均值
ints.stream().collect(Collectors.averagingInt(Integer::intValue));

//通过summarizingInt同时求总和、平均值、最大值、最小值
ints.stream().collect(Collectors.summarizingInt(Integer::intValue));

Stream 终端操作(collect)

List<Integer> ints = Arrays.asList(1, 1, 2, 2, 3);
//返回List
ints.stream().collect(Collectors.toList());

//返回Set
ints.stream().collect(Collectors.toSet());

//返回Map
ints.stream().collect(Collectors.toMap(k -> k, v -> v, (v1, v2) -> v1));

//group分组
ints.stream().collect(Collectors.groupingBy(k -> k));

//partitioningBy分区
ints.stream().collect(Collectors.partitioningBy(k -> k % 2 == 0));

Stream参考文献

  • 深入理解Java Stream流水线
  • Java 8中Stream API 的这些奇技淫巧!
  • 使用Stream API优化代码
  • java.util.stream 库简介

喜欢 (0)