AndroidStudio与Java8（二）

OK，接着上一篇 正式开始说Java8中的流（Stream）和函数式接口（FunctionalInterface）。
这两个重点东西可惜需要minSdk为24，不过说不定慢慢就用上了，另外，学习Stream对RxJava的理解会更进一步。我第一次接触RxJava时，第一反应就是：这家伙就是Java8的Stream。

声明：这篇文章结合http://www.jb51.net/article/48304.htm 和
http://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/ 两篇文章整理而成。

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正式版了。