Java 8 Stream API
package com.excmmy.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class test1 {
public static void main(String[] args) {
testMatch();
}
public static void testMap() {
/*
* map()
* 将每个 stream 的元素 映射成另外一个元素
* */
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> newNums = nums.stream().map(item -> item * item).collect(Collectors.toList());
System.out.println(newNums);
}
public static void testFlatMap() {
/*
* flatMap() 将 input 中的层级机构扁平化, 就是将最底层的元素抽出来放到一起
* */
List<Integer> num1 = Arrays.asList(1, 10);
List<Integer> num2 = Arrays.asList(1, 2, 3);
List<Integer> num3 = Arrays.asList(2, 3, 4, 5);
Stream<List<Integer>> input = Stream.of(num1, num2, num3);
List<Integer> collect = input.flatMap(item -> item.stream()).collect(Collectors.toList());
System.out.println(collect);
}
public static void testFilter() {
/*
* filter()
* 对原始 Stream 进行某项测试, 通过测试的元素被留下来生成一个新的 Stream, Lambda后面跟的是一个表达式, 条件为真的时候返回
* */
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> collect = nums.stream().filter(item -> {
if ((item * 2) > 5) {
return true; // true 返回当前 item
}
return false; // false 不返回
}).collect(Collectors.toList());
System.out.println(collect);
}
public static void testForEach() {
/*
* forEach()
* forEach方法接收一个 Lambda 表达式, 然后在 Stream 的每一个元素上执行该表达式
* 当需要为多核心优化时, 可以使用 parallelStream().forEach(), 只是此时原有元素的次序没法保证
* forEach是terminal操作, 它执行后, Stream 的元素就被"消费"掉了, 也就是说 forEach 在 Stream中 只能使用一次, 并且在最后一次使用
* forEach 不能修改自己包含的本地变量值, 也不能用break/return之类的关键字提前结束循环
*
* peak()
* 与 forEach() 相同, 但是 它不是terminal操作, 可以继续执行其他操作
* */
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
nums.stream().filter(item -> {
if ((item * 2) > 5) {
return true; // true 返回当前 item
}
return false; // false 不返回
}).forEach(System.out::println);
}
public static void testFindFirst() {
/*
* Optional.ofNullable()
* 返回值类型Optional, 作为一个容器, 它可能含有某值, 或者不包含, 使用它的目的是尽可能避免NullPointerException
* */
String text = null;
Integer integer = Optional.ofNullable(text).map(String::length).orElse(-1);
System.out.println(integer);
}
public static void testReduce() {
/*
* reduce()
* 主要作用是把Stream元素组合起来, 它提供一个起始值,
* 然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第n个元素组合
* 示例中, 相当于求所有的和
* */
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
Integer reduce = nums.stream().reduce(0, (item1, item2) -> item1 + item2);
System.out.println(reduce);
// 字符串连接, concat = "ABCD", 第一个参数（空白字符）即为起始值
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
System.out.println(concat);
// 求和, sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
System.out.println(sumValue);
// 求和, sumValue2 = 10, 无起始值, 由于可能没有足够的元素，返回的是 Optional
int sumValue2 = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
System.out.println(sumValue2);
}
public static void testLimitAndSkip() {
/*
* limit() / skip()
* limit 返回 Stream 的前面 n 个元素
* skip 则是扔掉前 n 个元素
* */
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 static void testLimitAndSkip2() {
/*
* limit() / skip()
* 把它们放在 Stream 的排序操作后无法达到 short-circuiting 目的
* 此时系统并不知道 Stream 排序后的次序如何, 所以 sorted 中的操作看上去就像完全没有被limit或者skip一样
* */
List<Person> persons = new ArrayList();
for (int i = 1; i <= 5; i++) {
Person person = new Person(i, "name" + i);
persons.add(person);
}
List<Person> personList2 = persons.stream().sorted((p1, p2) ->
p1.getName().compareTo(p2.getName())).limit(2).collect(Collectors.toList());
System.out.println(personList2);
}
public static void testSorted() {
/*
* sorted()
* 对 Stream 的排序通过 sorted 进行
* 它比数组的排序更强之处在于你可以首先对Stream进行各类map、filter、limit、skip甚至distinct来减少元素数量后再排序
* 当然, 这种优化是有business logic上的局限性的: 即不要求排序后再取值
* */
List<Person> persons = new ArrayList();
for (int i = 1; i <= 5; i++) {
Person person = new Person(i, "name" + i);
persons.add(person);
}
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2);
}
public static void testMatch() {
/*
* allMatch：Stream 中全部元素符合传入的 predicate，返回 true;
* anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true;
* noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true.
* */
List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);
}
private static class Person {
public int no;
private String name;
private int age;
public Person(int no, String name) {
this.no = no;
this.name = name;
}
public Person(int no, String name, int age) {
this.no = no;
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}
Stream 的特性可以归纳为：
- 不是数据结构;
- 它没有内部存储，它只是用操作管道从source（数据结构、数组、generator function、IO channel）抓取数据;
- 它也绝不修改自己所封装的底层数据结构的数据。例如Stream的filter操作会产生一个不包含被过滤元素的新Stream，而不是从source删除那些元素;
- 所有Stream的操作必须以lambda表达式为参数;
- 不支持索引访问;
- 你可以请求第一个元素，但无法请求第二个，第三个，或最后一个;
- 很容易生成数组或者List;
- 惰性化;
- 很多Stream操作是向后延迟的，一直到它弄清楚了最后需要多少数据才会开始;
- Intermediate操作永远是惰性化的;
- 并行能力;
- 当一个 Stream 是并行化的，就不需要再写多线程代码，所有对它的操作会自动并行进行的;
- 可以是无限的。集合有固定大小，Stream 则不必。limit(n)和findFirst()这类的short-circuiting操作可以对无限的Stream进行运算并很快完成。
