OK,接着上一篇 正式开始说Java8中的流(Stream)和函数式接口(FunctionalInterface)。
这两个重点东西可惜需要minSdk为24,不过说不定慢慢就用上了,另外,学习Stream对RxJava的理解会更进一步。我第一次接触RxJava时,第一反应就是:这家伙就是Java8的Stream。
Stream
Stream代表着一串你可以在其上进行多种操作的元素。流操作既可以是连续的也可以是中断的。中断操作返回操作结果。而连续操作返回流本身,这样就可以在该行上继续操作。流是创建在数据源上的,例如:Collection、List和Set。流操作既可以顺序执行也可以并行执行。
Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的,它更像一个高级版本的 Iterator。Iterator只能一个一个遍历元素并对其执行某些操作;而对于 Stream,用户只要给出需要对其包含的元素执行什么操作,Stream 会隐式地在内部进行遍历,做出相应的数据操作。
Stream 是单向的,数据只能遍历一次,遍历过一次后即用尽了,就好比水流流过,一去不复返。
而和迭代器又不同的是,Stream 可以并行化操作,迭代器只能命令式地、串行化操作。顾名思义,当使用串行方式去遍历时,每个 item 读完后再读下一个 item。而使用并行去遍历时,数据会被分成多个段,其中每一个都在不同的线程中处理,然后将结果一起输出。Stream 的并行操作依赖于 Java7 中引入的 Fork/Join 框架(JSR166y)来拆分任务和加速处理过程。Java 的并行 API 演变历程基本如下:
- 1.0-1.4 中的 java.lang.Thread
- 5.0 中的 java.util.concurrent
- 6.0 中的 Phasers 等
- 7.0 中的 Fork/Join 框架
- 8.0 中的 Lambda
Stream 的另外一大特点是,数据源本身可以是无限的。
流的构成
当我们使用一个流的时候,通常包括三个基本步骤:
获取一个数据源(source)→ 数据转换→执行操作获取想要的结果。
每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以像链条一样排列,变成一个管道,如下图所示。
流的操作类型
- Intermediate:一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流,做出某种程度的数据映射/过滤,然后返回一个新的流,交给下一个操作使用。这类操作都是惰性化的(lazy),就是说,仅仅调用到这类方法,并没有真正开始流的遍历。
- Terminal:一个流只能有一个 terminal 操作,当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行,才会真正开始流的遍历,并且会生成一个结果,或者一个 side effect。
- Short-circuiting:
对于一个 intermediate 操作,如果它接受的是一个无限大(infinite/unbounded)的 Stream,但返回一个有限的新 Stream。
对于一个 terminal 操作,如果它接受的是一个无限大的 Stream,但能在有限的时间计算出结果。
当操作一个无限大的 Stream,而又希望在有限时间内完成操作,则在管道内拥有一个 short-circuiting 操作是必要非充分条件。
一个流操作的示例
int sum = list.stream()
.filter(w -> w.getColor() ==RED)
.mapToInt(w -> w.getWeight())
.sum();
stream() 获取当前list的 source,filter 和 mapToInt 为 intermediate 操作,进行数据筛选和转换,最后一个 sum() 为 terminal 操作,对符合条件的全部红色的物品的重量求和。
简单来说,对 Stream 的使用就是实现一个 filter-map-reduce 过程,产生一个最终结果,或者导致一个副作用(side effect)。
流的构造
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
需要注意的是,对于基本数值型,目前有三种对应的包装类型 Stream:IntStream、LongStream、DoubleStream。
当然我们也可以用 Stream、Stream >、Stream,但是 boxing 和 unboxing 会很耗时,所以特别为这三种基本数值型提供了对应的 Stream。
流转换为其它数据结构
// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();
流操作的分类
- Intermediate:
map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered - Terminal:
forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator - Short-circuiting:
anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit
主要的几种流操作
map
map操作是对流内数据的转换。
//转换大写
List<String> output =
wordList.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
//这段代码把所有的单词转换为大写。
//平方数
List<Integer> nums = Arrays.asList(1, 2, 3, 4);
List<Integer> squareNums =
nums.stream()
.map(n -> n * n)
.collect(Collectors.toList());
//这段代码生成一个整数 list 的平方数 {1, 4, 9, 16}。
flatMap
map 生成的是个 1:1 映射,每个输入元素,都按照规则转换成为另外一个元素。还有一些场景,是一对多映射关系的,这时需要 flatMap。
Stream<List<Integer>> inputStream = Stream.of(
Arrays.asList(1),
Arrays.asList(2, 3),
Arrays.asList(4, 5, 6)
);
Stream<Integer> outputStream = inputStream.flatMap((childList) -> childList.stream());
flatMap 把 inputStream 中的层级结构扁平化,就是将最底层元素抽出来放到一起,最终 output 的新 Stream 里面已经没有 List 了,都是直接的数字。
sorted
stringCollection
.stream()
.sorted()
.forEach(System.out::println);
Sorted是一个连续操作,它返回流的已排序版本。如果你没有显示的指定Comparator,那么流中元素的排序规则为默认的。
filter
filter 对原始 Stream 进行筛选,被留下来生成一个新 Stream。
// 筛选偶数
Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens = Stream.of(sixNums)
.filter(n -> n%2 == 0)
.toArray(Integer[]::new);
forEach
forEach 方法接收一个 Lambda 表达式,然后在 Stream 的每一个元素上执行该表达式。
// 普通的forEach循环
for (Person p : roster) {
if (p.getGender() == Person.Sex.MALE) {
System.out.println(p.getName());
}
}
// Java 8
roster.stream()
.filter(p -> p.getGender() == Person.Sex.MALE)
.forEach(p -> System.out.println(p.getName()));
注意:
forEach 是 terminal 操作,因此它执行后,Stream 的元素就被“消费”掉了,你无法对一个 Stream 进行两次 terminal 运算。
forEach 不能修改自己包含的本地变量值,也不能用 break/return 之类的关键字提前结束循环。
peek
peek 对每个元素执行操作并返回一个新的 Stream。
Stream.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());
findFirst
这是一个 termimal 兼 short-circuiting 操作,它总是返回 Stream 的第一个元素,或者空。
它的返回值类型是:Optional(这是一个函数式接口,在后边介绍)。
reduce
这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值(种子),然后依照运算规则(BinaryOperator),和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说,字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。
例如 Stream 的 sum 就相当于: Integer sum = integers.reduce(0, (a, b) -> a+b);
或 Integer sum = integers.reduce(0, Integer::sum);
也有没有起始值的情况,这时会把 Stream 的前面两个元素组合起来,返回的是 Optional。
示例如下:
// 字符串连接,concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D")
.reduce("", String::concat);
// 求最小值,minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0)
.reduce(Double.MAX_VALUE, Double::min);
// 求和,sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4)
.reduce(0, Integer::sum);
// 求和,sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4)
.reduce(Integer::sum).get();
// 过滤,字符串连接,concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F")
. filter(x -> x.compareTo("Z") > 0)
. reduce("", String::concat);
limit/skip
limit 返回 Stream 的前面 n 个元素;
skip 则是扔掉前 n 个元素(它是由一个叫 subStream 的方法改名而来)。
public void testLimitAndSkip() {
List<Person> persons = new ArrayList();
for (int i = 1; i <= 10000; i++) {
Person person = new Person(i, "name" + i);
persons.add(person);
}
List<String> personList2 = persons.stream()
.map(Person::getName)
.limit(10)
.skip(3)
.collect(Collectors.toList());
System.out.println(personList2);
}
public String getName() {
System.out.println(name);
return name;
}
输出结果为
name1 name2 name3 name4 name5 name6 name7 name8 name9 name10
[name4, name5, name6, name7, name8, name9, name10]
match
Stream 有三个 match 方法,从语义上说:
- allMatch:
Stream 中全部元素符合传入的 predicate,返回 true - anyMatch:
Stream 中只要有一个元素符合传入的 predicate,返回 true - noneMatch:
Stream 中没有一个元素符合传入的 predicate,返回 true
进阶:自己生成流(Stream.generate)
通过实现 Supplier 接口,你可以自己来控制流的生成。
Stream.generate(new PersonSupplier())
.limit(10)
.forEach(p -> System.out.println(p.getName()+p.getAge()));
private class PersonSupplier implements Supplier<Person> {
private int index = 0;
private Random random = new Random();
@Override
public Person get() {
return new Person("TestUser" + index++, random.nextInt(100));
}
}
Stream.iterate
iterate 跟 reduce 操作很像,接受一个种子值,和一个 UnaryOperator(例如 f)。然后种子值成为 Stream 的第一个元素,f(seed) 为第二个,f(f(seed)) 第三个,以此类推。
//生成一个等差数列
Stream.iterate(0, n -> n + 3)
.limit(10)
.forEach(x -> System.out.print(x + “ ”));
//输出:0 3 6 9 12 15 18 21 24 27
进阶:用 Collectors 进行 reduction 操作(groupingBy/partitioningBy)
//按照年龄归组
Map<Integer, List<Person>> personGroups =
Stream.generate(new PersonSupplier())
.limit(100)
.collect(Collectors.groupingBy(Person::getAge));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Integer, List<Person>> persons = (Map.Entry) it.next();
System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());
}
上面的 code,首先生成 100 人的信息,然后按照年龄归组,相同年龄的人放到同一个 list 中,可以看到如下的输出:
Age 0 = 2 Age 1 = 2 Age 5 = 2 Age 8 = 1 Age 9 = 1 Age 11 = 2 ……
//按照未成年人和成年人归组
Map<Boolean, List<Person>> children =
Stream.generate(new PersonSupplier())
.limit(100)
.collect(Collectors.partitioningBy(p -> p.getAge() < 18));
System.out.println("Children number: " + children.get(true).size());
System.out.println("Adult number: " + children.get(false).size());
输出结果:
Children number: 23 Adult number: 77
在使用条件“年龄小于 18”进行分组后可以看到,不到 18 岁的未成年人是一组,成年人是另外一组。
partitioningBy 其实是一种特殊的 groupingBy,它依照条件测试的是否两种结果来构造返回的数据结构,get(true) 和 get(false) 能即为全部的元素对象。
函数式接口(FunctionalInterface)
Java8提供了几个全新的函数式接口。
断言接口(Predicates)
Predicates是只拥有一个参数的Boolean型功能的接口。
这个接口拥有多个默认方法用于构成predicates复杂的逻辑术语。
Predicate<String> predicate = (s) -> s.length() > 0;
predicate. apply("foo"); // true
predicate.negate(). apply(“foo”); // false
//Android不能使用negate()
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
功能接口(Functions)
Functions接受一个参数并产生一个结果。默认方法能够用于将多个函数链接在一起。
Function<T, R> {
R apply(T var1);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
throw new RuntimeException("Stub!");
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
throw new RuntimeException("Stub!");
}
static default <T> Function<T, T> identity() {
throw new RuntimeException("Stub!");
}
}
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString =toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"
供应接口(Suppliers)
Suppliers对于给定的泛型类型产生一个实例.
不同于Functions,Suppliers不需要任何参数。
public interface Supplier<T> {
T get();
}
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person
消费接口(Consumers)
Consumers代表在只有一个输入参数时操作被如何执行。
@FunctionalInterface
public interface Consumer<T> {
void accept(T var1);
default Consumer<T> andThen(Consumer<? super T> after) {
throw new RuntimeException("Stub!");
}
}
Consumer<Person> greeter =(p) -> System.out.println("Hello, " + p.getName());
greeter.accept(new Person("Lucy", 18));
比较接口(Comparators)
Comparators在老版本中就已经被熟知。
Java8向该接口中添加了多种默认方法。
Comparator<Person> comparator =
(p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0
...
方法太多,还是看看API吧。
选项接口(Optionals)
Optionals并不是功能性接口,反而它是一种特殊的工具用来阻止NullPointerException。
Optional是一种可以包含null和non-null值的简单容器。考虑到方法可以返回non-null结果,偶尔也可能任何都不返回。在Java8中,你可以返回Optional而不是返回null。
Optional<String> optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse(“fallback”); // “bam” 如果为空则返回“fallback”
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
Date API
Java8提供了新的Date API。
- Clock 时钟
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date
- Timezones 时区
- LocalDate 本地日期
LocalDate 表示了一个确切的日期,比如 2014-03-11。该对象值是不可变的,用起来和LocalTime基本一致。 - LocalDateTime 本地日期时间
最后
关于Java8的特性就介绍完了,坐等Android Studio2.4正式版了。