Java8 Stream笔记

什么是Stream？

Java 8 中的 Stream 是对数组和集合（Collection）对象功能的增强，
专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。
 

Stream的特性？

➢ 不存储数据。Stream 是基于数据源的对象，它本身不存储数据元素，而是通过管道将数据源的元素传递给操作。

➢ 函数式编程。Stream 的操作不会修改数据源，例如filter不会将数据源中的数据删除。

➢ 延迟操作。Stream 的很多操作如filter，map等中间操作是延迟执行的，只有到终点操作才会将操作顺序执行。

➢ 可以解绑。对于无限数量的流，有些操作是可以在有限的时间完成的，比如limit(n) 或 findFirst()，
	这些操作可是实现”短路”(Short-circuiting)，访问到有限的元素后就可以返回。

➢ 纯消费。Stream 的元素只能访问一次，类似Iterator，操作没有回头路，
	如果新访问流的元素，得重新生成一个新的流。

Stream的类型

➢ 串行流
	Collection.stream() 创建的串行流
	IntStream.range(int, int) 创建的串行流
	sequential() 方法可以将并行流转换成串行流。

➢ 并行流
	Collection.parallelStream() 为集合创建并行流
	parallel() 方法可以将串行流转换成并行流

Stream的操作类型

流的操作类型分为：中间操作、终止操作、短路操作

➢ 中间操作

一个流可以后面跟随零个或多个 中间(intermediate) 操作。
其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。
这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。 

	○ map (mapToInt, flatMap 等) 映射，输入一个T类型的元素，返回一个R类型的元素；
		如果返回的类型是也是Stream类型，会直接把Stream放入原Stream中
	○ filter 筛选，匹配符合规则的元素
	○ distinct 筛选，通过hashcode 和 equals去除重复元素
	○ sorted 排序，按自然顺序排序，产生一个新流
	○ peek 用于查看每个元素，但不改变流的操作的方法。
		它接收一个Consumer类型的参数，该参数用于针对每个元素执行副作用操作。
		该方法返回一个与原始流相同的新流，因此可以进行链式操作。
	○ limit 筛选，取不超过给定数量的元素
	○ skip 筛选，跳过前n个元素，若流中元素不足n个则返回空流
	○ parallel 将串行流转换成并行流
	○ sequential 将并行流转换成串行流
	○ unordered 除去排序约束

➢ 终止操作

一个流只能有一个 终止(terminal) 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。
所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，
并且会生成一个结果，或者一个副作用(side effect)。

	○ forEach 遍历并逐个消费元素
	○ forEachOrdered 当多个线程并行处理时，按source原有的顺序输出
	○ toArray 把流转为数组
	○ reduce 规约，将流中元素按照指定规则合并成一个元素
	○ collect 收集，将流中元素收集到一个集合中
	○ min 返回流中最小的元素
	○ max 返回流中最大的元素
	○ count 统计流中元素个数
	○ anyMatch 流中元素是否有一个匹配规则p,有匹配返回true，无则false
	○ allMatch 流中元素是否全部匹配规则p,全部匹配返回true，否则false
	○ noneMatch 流中元素是否全部不匹配规则p
	○ findFirst 取流中第一个元素
	○ findAny 从流中任取一个元素
	○ iterator 将流转换为迭代器

➢ 短路操作

对于一个中间(intermediate) 操作，如果它接受的是一个无限流，它可以返回一个有限的新 Stream。
对于一个终止(terminal) 操作，如果它接受的是一个无限流，但能在有限的时间计算出结果。

如何创建Stream

Stream可以通过集合、数组或Stream自带的静态方法 of()、iterate()、generate() 来创建。

➢ 通过集合创建流

List<String> list = Arrays.asList("a", "b", "c");

// 创建顺序流
Stream<String> stream = list.stream();

// 创建并行流
Stream<String> parallelStream = list.parallelStream();

➢ 通过数组创建流

int[] array={1,3,5,6,8};

IntStream stream = Arrays.stream(array);

➢ 通过Stream自带的静态方法 of()、iterate()、generate() 创建流

// Stream.of 为给定元素创建顺序流
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

// Stream.iterate 第一个参数是新流中的初始元素，
// 然后使用该数据做第二个参数也就是UnaryOperator函数的入参去计算第二元素，
// 然后把新计算得到的第二个元素作为入参继续计算第三个元素，以此循环可以制造无限个元素，
// 在实际使用中一般使用limit（n）方法去获取包含n个的流。
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);

// Stream.generate 方法主要用于生成一个无限连续的无序流，流中的元素由用户定义的supplier函数生成。
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

常用Api实例

➢ map

映射，输入一个T类型的元素，返回一个R类型的元素；

map(Function<? super T, ? extends R> mapper);

// 映射到其他对象
List<User> userList = list.stream().map(iteam -> {
            User user = new User();
            user.setSkuId(...)
            return user;
        }).collect(Collectors.toList());

// 取对象list中的一个属性为新的list
List<Integer> list2 = userList.stream()
                .map(User::getAge)
                .collect(Collectors.toList());

// 将字符串list中的字符串全大写
List<String> collect = strs.stream().map(String::toUpperCase).collect(Collectors.toList());

// 将字符串list中的字符长度
List<Integer> lengths = strs.stream().map(String::length).collect(Collectors.toList());

➢ reduce

归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，
如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。

reduce((T, T) -> T);
reduce(T, (T, T) -> T);

// 有初始值，计算年龄总和，两种写法都可:
int age = list.stream().reduce(0, (user1, user2) -> user1.getAge() + user2.getAge());
int sum = list.stream().map(User::getAge).reduce(0, (a, b) -> a + b);
int sum = list.stream().map(User::getAge).reduce(0, Integer::sum);

// 无初始值，此时返回的是Optional 类型
Optional sum = list.stream().map(User::getAge).reduce(Integer::sum);

➢ collect

收集Stream流到集合和指定集和中

//1.收集数据到list集合中
stream.collect(Collectors.toList())

//2.收集数据到set集合中
stream.collect(Collectors.toSet())

//3.收集数据到指定的集合中
stream.collect(Collectors.toCollection(HashSet::new))

数据聚合操作

//最大值
Collectors.maxBy();

//最小值
Collectors.minBy();

//总和
Collectors.summingInt();
Collectors.summingDouble();
Collectors.summingLong();

//平均值
Collectors.averagingInt();
Collectors.averagingDouble();
Collectors.averagingLong();

//总个数
Collectors.counting();


//或者使用lambda表达式取最大值
Optional<User> maxCollect2 = userList.stream().collect(Collectors.maxBy((s1, s2) -> s1.getJgid() - s2.getJgid()));

//或者使用lambda表达式取最小值
Optional<User> minCollect = userList.stream().collect(Collectors.minBy((s1, s2) -> s1.getJgid() - s2.getJgid()));

//或者使用lambda表达式取jgid总和
Integer sumCollect2 = userList.stream().collect(Collectors.summingInt(User::getJgid));

//或者使用lambda表达式取jgid平均值
Double avgScore2 = userList.stream().collect(Collectors.averagingInt(User::getJgid));

//(聚合)统计数量
Long count = userList.stream().collect(Collectors.counting());

分组操作

//接收一个 Function 参数
groupingBy(Function<? super T, ? extends K> classifier)

//或者使用lambda表达式
Map<Integer, List<User>> jgidMap2 = userList.stream().collect(Collectors.groupingBy(User::getJgid));

//jgid奇数一组偶数一组
Map<String, List<User>> jgidMap3 = userList.stream().collect(Collectors.groupingBy(s -> {
    if (s.getJgid() % 2 == 0) {
        return "jgid为偶数";
    } else {
        return "jgid为奇数";
    }
}));

//根据jgid分组，且规定为最大一组(规约：reducing)
Map<Integer, Optional<User>> jgidMap4 = 
		userList.stream().collect(Collectors.groupingBy(User::getJgid,
		       Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(User::getJgid)))
		));

多级分组操作

//接收两个参数: 1.Function 参数  2.Collector多级分组
groupingBy(Function<? super T, ? extends K> classifier,Collector<? super T, A, D> downstream) 

Map<Integer, Map<String, List<User>>> collect = 
				userList.stream().collect(Collectors.groupingBy(User::getJgid,
	                Collectors.groupingBy(user -> {
	                    if (user.getId() % 2 == 0) {
	                        return "id是偶数";
	                    } else {
	                        return "id是奇数";
	                    }
                })));

分区操作

根据返回值是否为 true，把集合分为两个列表，一个 true 列表，一个 false 列表。
和分组的区别在于分组可以有多个组，分区只会有两个区( true 和 false)

//1.一个参数
partitioningBy(Predicate<? super T> predicate)
 
//2.两个参数(多级分区)
partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

Map<Boolean, List<User>> collect = 
		userList.stream().collect(Collectors.partitioningBy(s -> {
            return s.getJgid() % 2 == 0;
        }));

stream.collect(Collectors.partitioningBy(s -> s % 2 == 0));

拼接操作

//无参数--等价于 joining("");
joining()

//一个参数，拼接符
joining(CharSequence delimiter)

//三个参数(拼接符+前缀+后缀)
joining(CharSequence delimiter, CharSequence prefix,CharSequence suffix)


String collect1 = userList.stream().map(User::getName).collect(Collectors.joining());
String collect2 = userList.stream().map(User::getName).collect(Collectors.joining(","));
String collect3 = userList.stream().map(User::getName).collect(Collectors.joining(",", "开始<", ">结束"));

toArray

toArray();
toArray(IntFunction<A[]> generator);


//1.使用无参,收集到数组,返回值为 Object[](Object类型将不好操作)
Object[] objects = userList.stream().toArray();

//2.使用有参,可以指定将数据收集到指定类型数组,方便后续对数组的操作
User[] user = userList.stream().toArray(User[]::new);