【编者按】在之前文章中,我们介绍了Java 8和Scala的Lambda表达式对比。在本文,将进行Hussachai Puripunpinyo Java和Scala对比三部曲的第二部分,主要关注Stream和Collection,由 OneAPM 工程师翻译。
以下为译文
首先,为大家做一个简短的介绍,collection是有限的数据集,而stream是数据的序列集,可以是有限的或无限的。
Streams API是Java 8中新发布的API,主要用于操作collection和streaming数据。Collections API会改变数据集状态,而Streams API则不会。例如,当你调用Collections.sort(list)时,该方法会对传入的参数进行排序,而调用list.stream().sorted() 则会复制一份数据进行操作,保持原数据不变。 你可以在这里获得更多关于API数据流的信息
以下是笔者从Java 8文档中摘出的collections和streams之间的比较。强烈建议大家阅读 完整版 。
Streams和collections有以下几点区别:
1. 无存储。steam 不是存储数据元素的数据结构。而是通过计算操作管道从源头传输数据元素。
2.本质是函数。对Stream对象操作能得到一个结果,但是不会修改原始数据。
3. Laziness-seeking(延迟搜索):Stream的很多操作如filter、map、sort和duplicate removal(去重)可以延迟实现,意思是我们只要检查到满足要求的元素就可以返回。
4. 可能是不受限制的:Streams允许Client取足够多的元素直到满足某个条件为止。而Collections不能这么做。
5. 消耗的。Steam中的元素在steam生存期内只能被访问一次。
Java 和 Scala 都可以很简单地同时计算 collection 中的值。在 Java 中,你只需调用parallelStream()* 或者 stream().parallel(),而不是stream()。在 Scala 中,在调用其他方法之前,必须先调用 par()函数。而且可以通过添加parallelism来提高程序的性能。不幸的是,大多数时间它的执行速度都非常慢。事实上,parallelism是一个很容易被误用的功能。 点这阅读这有趣的文章
在 JavaDoc 中, parallelStream()方法的介绍是:可能返回一个并行的stream(collection作为数据源),所以它也可能返回一个串行 stream。( 有人做过关于该API的研究 )
图像标题
Java 的 Stream API 是延后执行的。这意味着,没有指定一个终结操作(比如 collect() 方法调用),那么所有的中间调用(比如 filter 调用)是不会被执行的。延迟的流处理主要是为了优化stream API 的执行效率。比如对一个数据流进行过滤、映射以及求和运算,通过使用延后机制,那么所有操作只要遍历一次,从而减少中间调用。同时,延后执行允许每个操作只处理必要的数据。相反,Scala的collections是即时处理的。这样是否意味着,在测试中,Java Stream API始终优于 Scala ?如果只比较Java的 Stream API 和 Scala的Collection API,那么Java Stream API 的确优于 Scala Collection API。但在 Scala 中有更多的选择。通过简单地调用toStream(),就可以将一个 Collection 转换成一个Stream,或者可以使用 view (一种提供延后处理能力的Collection)来处理数据集合。
下面粗略介绍下Scala的Stream和View特性
Scala的Stream
Scala的Stream和Java的有所不同。在Scala Stream中,无需调用终结操作去取得Stream的结果。Stream是一个继承 Abstractseq 、 Linearseq 和 GenericTraversableTemplate trait的抽象类。所以,你可以把Stream当作 SEQ 。
如果你不熟悉Scala,可以将Seq当作Java里的List。(Scala 中的 List 不是一个接口)。
这里需知道Streams 中的元素都是延迟计算的,正因为此,Stream能够计算无限数据流。如果要计算集合中的所有元素,Stream和List有相同的性能。一旦计算出结果,数值将被缓存。Stream有一个force函数,能够强制评估stream再返回结果。注意,不要在无限流中调用该函数,也不要强制该API处理整个stream的操作,比如size()、tolist()、foreach()等,这些操作在Scala的Stream中都是隐式的。
在Scala Stream中实现Fibonacci数列。
def fibFrom(a: Int, b: Int): Stream[Int] = a #:: fibFrom(b, a + b) val fib1 = fibFrom(0, 1) //0 1 1 2 3 5 8 … val fib5 = fibFrom(0, 5) //0 5 5 10 15 … //fib1.force //Don’t do this cause it will call the function infinitely and soon you will get the OutOfMemoryError //fib1.size //Don’t do this too with the same reason as above. fib1.take(10) //Do this. It will take the first 10 from the inifite Stream. fib1.take(20).foreach(println(_)) //Prints 20 first numbers
:: 是collection中常用的连接数据的方法。而 #:: 表示是连接数据但是是延迟执行的(Scala中的方法名都很随意)。
Scala的View
再次重申,Scala的collection是一个严格collection,而view是非严格的。View 是基于一个基础 collection 的 collection,其中所有的转换都会延迟执行。通过调用 view 函数可以将严格collection转换成 view,也可以通过调用 force 方法转换回来。View 并不缓存结果,每次调用时才会执行转换。就像数据库的 View,但它是虚拟collection。
创建一个数据集。
public class Pet { public static enum Type { CAT, DOG } public static enum Color { BLACK, WHITE, BROWN, GREEN } private String name; private Type type; private LocalDate birthdate; private Color color; private int weight; ... }
假设有一个宠物集,接下来会利用该集合详细说明。
过滤器
要求 :从集合过滤一只胖乎乎的宠物,胖乎乎的定义是体重超过50磅,还想得到一个在2013年1月1日出生的宠物名单。下面的代码片段显示了如何以不同的方式实现该滤波器的工作。
Java 方法1 :传统方式
//Before Java 8 List<Pet> tmpList = new ArrayList<>(); for(Pet pet: pets){ if(pet.getBirthdate().isBefore(LocalDate.of(2013, Month.JANUARY, 1)) && pet.getWeight() > 50){ tmpList.add(pet); } }
这种方式在命令式语言中十分常见。首先,必须创建一个临时集合,然后遍历所有元素,存储满足条件的元素到临时集中。的确有点绕口,但其结果和效率都非常不错。但本人不得不扫兴地说,传统方法比Streams API更快。不过,完全不用担心性能问题,因为代码的简洁比轻微的性能增益更重要。
Java 方法2 :Streams API
//Java 8 - Stream pets.stream() .filter(pet -> pet.getBirthdate().isBefore(LocalDate.of(2013, Month.JANUARY, 1))) .filter(pet -> pet.getWeight() > 50) .collect(toList())
以上代码表示,使用Streams API过滤集合中的元素。之所以故意两次调用过滤函数,是想表明Streams 的 API 设计就像一个 Builder pattern。在Builder pattern调用构建方法之前,可以将各种方法串联起来。在Streams API中,构建方法被称为终结操作,非终结操作的叫做中间操作。终结操作可能不同于构造函数,因为它在 Streams API 中只能被调用一次。但还有很多可使用的终结操作,比如collect、count、min、max、iterator、toArray。这些操作会产生结果,而终端操作会消耗值,例如forEach。那么,你认为传统方法和 Streams API 哪一个的可读性更强?
Java 方法3 :Collections API
//Java 8 - Collection pets.removeIf(pet -> !(pet.getBirthdate().isBefore(LocalDate.of(2013, Month.JANUARY, 1)) && pet.getWeight() > 50)); //Applying De-Morgan's law. pets.removeIf(pet -> pets.get(0).getBirthdate().toEpochDay() >= LocalDate.of(2013, Month.JANUARY, 1).toEpochDay() || pet.getWeight() <= 50);
这种方法是最简短的。但是,它修改了原始集合,而前面的方法不会。removeif函数将Predicate<T>(函数接口)作为参数。Predicate是一个行为参数,它只有一个名为test抽象方法,只需要一个对象并返回布尔值。注意,这里必须使用“!”取反,或者可以应用De Morgan定理,使得代码看起来像二次声明。
Scala方法 :Collection、View和Stream
//Scala - strict collection pets.filter { pet => pet.getBirthdate.isBefore(LocalDate.of(2013, Month.JANUARY, 1))} .filter { pet => pet.getWeight > 50 } //List[Pet] //Scala - non-strict collection pets.views.filter { pet => pet.getBirthdate.isBefore(LocalDate.of(2013, Month.JANUARY, 1))} .filter { pet => pet.getWeight > 50 } //SeqView[Pet] //Scala - stream pets.toStream.filter { pet => pet.getBirthdate.isBefore(LocalDate.of(2013, Month.JANUARY, 1))} .filter { pet => pet.getWeight > 50 } //Stream[Pet]
Scala 的解决方案类似于Java 的Streams API。但首先,必须调用view函数把严格集转向非严格集,然后再用tostream函数把严格集转成一个stream。
接下来直接上代码。
分组
通过元素的一个属性对起所在集合做group。结果是Map<T, List<T>>,其中T是一个泛型类型。
要求:通过类型对宠物分组,诸如狗,猫等等。
注意:groupingBy是java.util.stream.Collectors的静态的helper method。
排序
根据属性对集合中的元素排序。结果会是任何类型的集合,根据配置来维持元素顺序。
要求:需按照类型、名字和颜色排序。
映射
将给定函数应用在集合元素中。根据定义的函数不同,其返回的结果类型也不同。
要求:需将宠物转化成字符串,以“%s — name: %s, color: %s”的格式。
寻找第一个
返回第一个能与指定predicate匹配的值。
要求 :找一个名为“Handsome”的宠物。无论有多少个“Handsome",只取第一个。
这个问题有点棘手。不知道你是否注意,在 Scala 中笔者所使用的是 find函数而不是 filter ?如果用 filter 代替 find,它就会计算集合中所有元素,因为 scala collection是严格的。但是,在 Java 的 Streams API 中你可以放心使用 filter,因为它会计算需要的第一个值,并不会计算所有元素。这就是延迟执行的好处!
接下来,向大家介绍 scala 中更多集合延迟执行的实例。我们假定 filter 总是返回 true,然后再取第二个值。将会是什么结果呢?
pets.filter { x => println(x.getName); true }.get(1) --- (1)
pets.toStream.filter { x => println(x.getName); true }.get(1) -- (2)
如上所示,(1)式将会打印出集合中所有宠物的名字,而(2)式则只输出前2个宠物的名字。这就是lazy collection的好处,总是延迟计算。
pets.view.filter { x => println(x.getName); true }.get(1) --- (3)
(3)式和(2)式会有一样的结果吗?错!它的结果和(1)是一样的,你知道为什么吗?
通过比较 Java 和 Scala 中的一些共同的操作方法 ——filter、group、map 和 find;很明显 Scala 的方法比 Java 更简洁。你更喜欢哪一个呢?哪一个的可读性更强?
在文章的下一个部分,我们将比较哪种方式更快。敬请期待!
原文链接: https://dzone.com/articles/java-8-vs-scalapart-ii-streams-api (责编/仲浩)
推荐阅读: Java 8 vs. Scala(一): Lambda表达式
90+位讲师,16大分论坛,Databricks公司联合创始人、Apache Spark首席架构师辛湜,Hadoop、HBase和Thrift项目的PMC成员和Committer、Kudu的发明人Todd Lipcon等海外专家将亲临 2015中国大数据技术大会 ,票价折扣即将结束, 预购从速 。