Java 丢了好多年,最近在拣起来,首先当然是了解这么多年来它的变化,于是发现了 Java 8 的
java.util.stream
。在学习和试验的过程中,相比较于 C# 和 javascript,有那么些心得,作文以记之。早些时间写过一篇《ES6 的 for..of 和 Generator,从伪数组 jQuery 对象说起》,和这个主题有点关系。其实我记得还有一篇讲 C# 的,没找到,也许只是想过,没写成,成了虚假记忆。
前言
之所以把 C#、JavaScript 和 Java 三种语言的实现写在一起,主要是为了放在一起有一个类比,可能会有助于理解。
集合数据
C# 的集合数据基类是 Collection<T>,它实现了 ICollection<T>接口,而 ICollection<T>
又从 IEnumerable<T> 接口继承——实际上要讨论的内容都基于 IEnumerable<T>
接口。另外还有一个非泛型的 IEnumerable
接口,不过建议大家尽量使用泛型,所以这个非泛型的接口就当我没说。顺便提一句,数组也是实现了 IEnumerable<T>
接口的。System.Linq
中提供的扩展大大方便了集合处理过程。
JavaScript 最常见的集合数据类型就是数组,自 ES6 发布以后,这个范围扩展到了 iterable 对象。不过这里要讨论的内容都是在 Array.prototype 中实现的。除此之外,underscore、lodash 这些第三方库中也实现了很多集合数据处理的方法,但不在本文讨论内容之内。
Java 的集合类型由 Collection<E> 接口定义。本文讨论的内容是 Java 8 的特性,在 java.util.stream
包中实现,由 Collection<E>.stream()
引入。
示例语言版本
- 后面示例中的部分 C# 语句可能需要支持 6.0 语言版本的编译器,如 Visual Studio 2015 或者 Visual Studio "15"
- JavaScript 代码都使用了 ES6 语法,目前大部分浏览器支持,Node 5 也完全支持。
- Java 要求 Java 8(或 1.8)版本
遍历
问题提出
给定一个名称列表,数组类型, ["Andy", "Jackson", "Yoo"]
,要求遍历出到的控制台。
C# 的遍历
对于集合来说,最常用的就是遍历,不过 for
,foreach
, while
之类大家都耳熟能详了,不再多说。这里说的是 forEach()
方法。
很遗憾,C# 的 Linq 扩展 里没有提供 ForEach()
方法,不过 All(IEnumerable<T>, Func<T, Boolean>)
和 Any(IEnumerable<T>, Func<T, Boolean>)
都可以代替。这两个方法的区别就在于第二个参数 Func<T, Boolean>
的返回值。这两个方法都会遍历集合,对集合中的每个元素依次调用第二个参数,Func<T, Boolean>
所指的委托方法,并检查其返回值,All()
检查到 false
中止遍历,而 Any()
检查到 true
中止遍历。
All()
的意思是,所有元素都符合条件则返回true
,所有只要有一个不符合条件,返回了false
,则中止遍历,返回false
;Any()
的意思是只要发现有元素符合条件则返回true
。
Func<T, Boolean>
是一个公用委托。Func<...>
系列公用委托都用于委托带有返回值的的方法,所有Func<..., TResult>
都是最后一个参数TResult
代表返回值类型。
因此,C# 的遍历输出可以这样实现
string[] names = { "Andy", "Jackson", "Yoo" };
names.All(name => {
Console.WriteLine(name);
return true;
});
string[] names = { "Andy", "Jackson", "Yoo" };
names.Any(name => {
Console.WriteLine(name);
return false;
});
有 Lambda 就是好
JavaScript 的遍历
JavaScript 的 Array 实现了 forEach
实例方法,即 Array.prototype.forEach()。
对于 JavaScript 的数组,可以这样遍历
var names = ["Andy", "Jackson", "Yoo"];
names.forEach(name => {
console.log(name);
});
对于 JavaScript 的伪数组,可以这样
var names = {
0: "Andy",
1: "Jackson",
2: "Yoo",
length: 3
};
[].forEach.call(names, name => {
console.log(name);
});
jQuery 的遍历
jQuery 是一个常用的 JavaScript 库,它封装的对象都是基于伪数组的,所以 jQuery 中经常用到遍历。除了网页元素集合外,jQuery 也可以遍历普通数组,有两种方式
可以直接把数组作为第一个参数,处理函数作为第二个参数调用 $.each()
。
const names = ["Andy", "Jackson", "Yoo"];
$.each(names, (i, name) => {
console.log(name);
});
也可以把数组封装成一个 jQuery 对象($(names)
),再在这个 jQuery 对象上调用 eash()
方法。
const names = ["Andy", "Jackson", "Yoo"];
$(names).each((i, name) => {
console.log(name);
});
两种方法的处理函数都一样,但是要注意,这和原生 forEach()
的处理函数有点不同。jQuery 的 each()
处理函数,第一个参数是序号,第二个参数是数组元素;而原生 forEach()
的处理函数正好相反,第一个参数是数组元素,第二个参数才是序号。
另外,$.each()
对伪数组同样适用,不需要通过 call()
来调用。
Java 的遍历
String[] names = { "Andy", "Jackson", "Yoo" };
List<String> list = Arrays.asList(names);
list.forEach(name -> {
System.out.println(name);
});
过滤(筛选)数据
问题提出
给出一组整数,需要将其中能被 3 整除选出来
[46, 74, 20, 37, 98, 93, 98, 48, 33, 15]
期望结果
[93, 48, 33, 15]
C# 中过滤使用 Where()
扩展
int[] data = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
int[] result = data.Where(n => n % 3 == 0).ToArray();
注意:Where()
的结果即不是数组也不是 List,需要通过 ToArray()
生成数组,或者通过 ToList()
生成列表。Linq 要在 ToArray()
或者 ToList()
或者其它某些操作的时候才会真正遍历,依次执行 Where()
参数提供的那个筛选函数。
JavaScript 中有 Array.prototype.filter
const data = [46, 74, 20, 37, 98, 93, 98, 48, 33, 15];
const result = data.filter(n => {
return n % 3 === 0;
});
Java 中使用到 java.util.stream.*
Java 中可以通过 java.util.stream.IntStream.of()
来从数组生成 stream 对象
final int[] data = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
int[] result = IntStream.of(data)
.filter(n -> n % 3 == 0)
.toArray();
需要注意的是,Arrays.asList(data).stream()
看起来也可以生成 stream 对象,但是通过调试会发现,这是一个 Stream<int[]>
而不是 Stream<Integer>
。原因是 asList(T ...a)
其参数可变参数,而且要求参数类型是类,所以 asList(data)
是把 data
作为一个 int[]
类型参数而不是 int
类型的参数数据。如果要从 int[]
生成 List<Integer>
,还得通过 IntStream
来处理
List<Integer> list = IntStream.of(data)
.boxed()
.collect(Collectors.toList());
映射处理
映射处理是指将某种类型的集合,将其元素依次映射成另一种类型,产生一个新类型的集合。新集合中的每个元素都与原集中的同样位置的元素有对应关系。
问题提出
这里提出一个精典的问题:成绩转等级,不过为了简化代码(switch 或多重 if 语句代码比较长),改为判断成绩是否及格,60 分为及格线。
偷个懒,就用上个问题的输入 [46, 74, 20, 37, 98, 93, 98, 48, 33, 15]
,
期望结果:
["REJECT","PASS","REJECT","REJECT","PASS","PASS","PASS","REJECT","REJECT","REJECT"]
C# 通过 Select()
来进行映射处理。
int[] scores = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
string[] levels = scores
.Select(score => score >= 60 ? "PASS" : "REJECT")
.ToArray();
JavaScript 通过 Array.prototype.map 来进行映射处理。
const scores = [46, 74, 20, 37, 98, 93, 98, 48, 33, 15];
const levels = scores.map(score => {
return score >= 60 ? "PASS" : "REJECT";
});
Java 的 Stream 提供了 mapToObj()
等方法处理映射
final int[] scores = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
String[] levels = IntStream.of(scores)
.mapToObj(score -> score >= 60 ? "PASS" : "REJECT")
.toArray(String[]::new);
与“筛选”示例不同,在“筛选”示例中,由于筛选结果是 IntStream
,可以直接调用 InStream::toArray()
来得到 int[]
。
但在这个示例中,mapToObj()
得到的是一个 Stream<String>
,类型擦除后就是 Stream
,所以 Stream::toArray()
默认得到的是一个 Object[]
而不是 String[]
。如果想得到 String[]
,需要为 toArray()
指定 String[]
的构造函数,即 String[]::new
。
生成查找表(如哈希表)
查找表在数据结构里的意义还是比较宽的,其中通过哈希算法实现的称为哈希表。C# 中通常是用 Directory<T>
,不过它是不是通过哈希实现我就不清楚了。不过 Java 中的 HashMap
和 Hashtable
,从名称就看得出来是实现。JavaScript 的字面对象据称也是哈希实现。
提出问题
现在有一个姓名列表,是按学号从 1~7 排列的,需要建立一个查找到,使之能通过姓名很容易找到对应的学号。
["Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen"]
期望结果
Andy => 1
Jackson => 2
Yoo => 3
Rose => 4
Lena => 5
James => 6
Stephen => 7
C# 使用 ToDictionary()
string[] names = { "Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen" };
int i = 1;
Dictionary<string, int> map = names.ToDictionary(n => n, n => i++);
C# Linq 扩展提供的若干方法都没有将序号传递给处理函数,所以上例中采用了临时变量计数的方式来进行。不过有一个看起来好看一点的办法,用 Enumerable.Range() 先生成一个序号的序列,再基于这个序列来处理
string[] names = { "Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen" };
IEnumerable<int> indexes = Enumerable.Range(0, names.Length);
Dictionary<string, int> map = indexes.ToDictionary(i => names[i], i => i + 1);
JavaScript 的两种处理办法
JavaScript 没有提供从 []
到 {}
的转换函数,不过要做这个转换也不是好麻烦,用 forEach
遍历即可
var map = (function() {
var m = {};
names.forEach((name, i) => {
m[name] = i + 1;
});
return m;
})();
为了不让临时变量污染外面的作用域,上面的示例中采用了 IEFE 的写法。不过,如果用 Array.prototype.reduce 则可以让代码更简洁一些
var map = names.reduce((m, name, i) => {
m[name] = i + 1;
return m;
}, {});
Java 的 Collectors
Java 的处理函数也没有传入序号,所以在 Java 中的实例和 C# 类似。不过,第一种方法不可用,因为 Java Lambda 的实现相当于是匿名类对接口的实现,只能访问局部的 final
变量,i
要执行 i++
操作,显然不是 final
的,所以只能用第二种办法
final String[] names = { "Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen" };
Map<String, Integer> map = IntStream.range(0, names.length)
.boxed()
.collect(Collectors.toMap(i -> names[i], i -> i + 1));
我只能说
.boxed()
是个大坑啊,一定要记得调。
汇总和聚合处理
汇总处理就是合计啊,平均数啊之类的,使用方式都差不多,所以以合计(Sum)为例。
汇总处理其实是聚合处理的一个特例,所以就同一个问题,再用普通的聚合处理方式再实现一次。
问题提出
已知全班成绩,求班总分,再次用到了那个数组
[46, 74, 20, 37, 98, 93, 98, 48, 33, 15]
期望结果:562
C# 的实现
C# 可以直接使用 Sum()
方法求和
int[] scores = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
int sum = scores.Sum();
聚合实现方式(用 Aggregate()
)
int[] scores = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
int sum = scores.Aggregate(0, (total, score) => {
return total + score;
});
聚合实现方式要灵活得多,比如,改成乘法就可以算阶乘。当然用于其它更复杂的情况也不在话下。前面生成查找表的 JavaScript 部分就是采用聚合来实现的。
JavaScript 都是通过聚合来实现的
const scores = [46, 74, 20, 37, 98, 93, 98, 48, 33, 15];
const sum = scores.reduce((total, score) => {
return total + score;
}, 0);
注意 C# 的初始值在前,JavaScript 的初始值在后,这是有区别的。参数顺序嘛,注意一下就行了。
Java 中使用 Stream::reduce 进行聚合处理
IntStream
提供了 sum()
方法
final int[] scores = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
final int sum = IntStream.of(scores).sum();
同样也可以用 reduce
处理
final int[] scores = { 46, 74, 20, 37, 98, 93, 98, 48, 33, 15 };
final int sum = IntStream.of(scores)
.reduce(0, (total, score) -> total + score);
综合应用
问题提出
已知全班 7 个人,按学号 从 1~7 分别是
["Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen"]
这 7 个人的成绩按学号序,分别是
[66, 74, 43, 93, 98, 88, 83]
有 Student
数组结构
Student {
number: int
name: string
score: int
}
要求得到全班 7 人的 student 数组,且该数组按分数从高到低排序
C# 实现
sealed class Student {
public int Number { get; }
public string Name { get; }
public int Score { get; }
public Student(int number, string name, int score) {
Number = number;
Name = name;
Score = score;
}
public override string ToString() => $"[{Number}] {Name} : {Score}";
}
Student[] students = Enumerable.Range(0, names.Length)
.Select(i => new Student(i + 1, names[i], scores[i]))
.OrderByDescending(s => s.Score)
.ToArray();
注意 C# 中排序有 OrderBy
和 OrderByDescending
两个方法,一般情况下只需要给一个映射函数,从原数据里找到要用于比较的数据即可使用其 >
、<
等运算符进行比较。如果比例起来比较复杂的,需要提供第二个参数,一个 IComparer<T>
的实现
JavaScript 实现
class Student {
constructor(number, name, score) {
this._number = number;
this._name = name;
this._score = score;
}
get number() {
return this._number;
}
get name() {
return this._name;
}
get score() {
return this._score;
}
toString() {
return `[${this.number}] ${this.name} : ${this.score}`;
}
}
const names = ["Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen"];
const scores = [66, 74, 43, 93, 98, 88, 83];
var students = names
.map((name, i) => new Student(i + 1, name, scores[i]))
.sort((a, b) => {
return b.score - a.score;
});
JavaScript 的排序则是直接给个比较函数,根据返回的数值小于0、等于0或大于0来判断是小于、等于还是大于。
Java 实现
final class Student {
private int number;
private String name;
private int score;
public Student(int number, String name, int score) {
this.number = number;
this.name = name;
this.score = score;
}
public int getNumber() {
return number;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
@Override
public String toString() {
return String.format("[%d] %s : %d", getNumber(), getName(), getScore());
}
}
final String[] names = { "Andy", "Jackson", "Yoo", "Rose", "Lena", "James", "Stephen" };
final int[] scores = { 66, 74, 43, 93, 98, 88, 83 };
Student[] students = IntStream.range(0, names.length)
.mapToObj(i -> new Student(i + 1, names[i], scores[i]))
.sorted((a, b) -> b.getScore() - a.getScore())
.toArray(Student[]::new);
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。