AndroidStudio与Java8

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();
1
2
3
4

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();
1
2
3
4
5
6
7
8
9

需要注意的是，对于基本数值型，目前有三种对应的包装类型 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. StringString str = stream.collect(Collectors.joining()).toString();
1
2
3
4
5
6
7
8
9

流操作的分类

• 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}。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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());
1
2
3
4
5
6

flatMap 把 inputStream 中的层级结构扁平化，就是将最底层元素抽出来放到一起，最终 output 的新 Stream 里面已经没有 List 了，都是直接的数字。

sorted

stringCollection    .stream()    .sorted()    .forEach(System.out::println);  
1
2
3
4

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);
1
2
3
4
5

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()));
1
2
3
4
5
6
7
8
9
10
11

注意： 
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());
1
2
3
4
5
6

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果为

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));     }}
1
2
3
4
5
6
7
8
9
10
11
12

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
1
2
3
4
5

进阶：用 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());}
1
2
3
4
5
6
7
8
9
10

上面的 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());
1
2
3
4
5
6
7

输出结果：

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();  
1
2
3
4
5
6
7
8
9
10
11

功能接口（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"  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

供应接口（Suppliers）

Suppliers对于给定的泛型类型产生一个实例. 
不同于Functions，Suppliers不需要任何参数。

public interface Supplier<T> {    T get();}Supplier<Person> personSupplier = Person::new;  personSupplier.get();   // new Person  
1
2
3
4
5
6

消费接口（Consumers）

Consumers代表在只有一个输入参数时操作被如何执行。

@FunctionalInterfacepublic 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)); 
1
2
3
4
5
6
7
8
9
10
11

比较接口（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  ...
1
2
3
4
5
6
7
8
9

方法太多，还是看看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"  
1
2
3
4
5

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
1
2
3
4

• Timezones 时区

• LocalDate 本地日期 
  LocalDate 表示了一个确切的日期，比如 2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。

• LocalDateTime 本地日期时间

最后

关于Java8的特性就介绍完了，坐等Android Studio2.4正式版了。