jdk8新特性之Stream 流

Stream 流

1.Stream 概述

JDK 1.8 版本及其以上支持！！！
利用流水线思想对于集合，数组数据进行处理和操作。涉及到数据筛选，排序，转换类型，限制个数，最终处理....并且在处理数据的过程中，对于数据的原始空间没有任何的修改，不影响原始数据。

2. Stream 流体验卡

ArrayList<String> list = new ArrayList<>();

list.add("卫龙辣条");
list.add("乐事薯片");
list.add("娃哈哈AD钙奶");
list.add("浪味仙");
list.add("旺仔牛奶");
list.add("喜之郎果冻");
list.add("不二家棒棒糖");
list.add("波力海苔");
list.add("大白兔奶糖");
list.add("双汇王中王");
list.add("牛肉干");
 
System.out.println();
list.stream()
         .skip(2)
         .limit(8)
         .filter(s -> s.length() > 4)
         .sorted(Comparator.comparing(String::length))
         .forEach(System.out::println);

3.Stream 流相关方法

Stream 处理的是 集合 或者 数组

// 集合对象
Stream<T> stream();
	集合对象调用可以直接获取对应当前集合存储元素的 Stream 流对象。

// 数组
Stream<T> Arrays.Stream(T[] t);
	利用 Arrays 工具类对当前需要按照 Stream 流方式操作的数据进行转换操作，根据当前数组的数据类型和数据存储情况，返回一个对应的 Stream 流对象

Stream 处理数据的【中间方法】

Stream<T> skip(long n);
	限制跳过当前 Stream 流对应元素的个数，【掐头】
Stream<T> limit(long n);
	限制当前 Stream 对应的元素总个数，【去尾】

Stream<T> sorted();
	对当前 Stream 流存储的进行排序操作，要求元素有自然顺序或者遵从 Comparable 接口，默认【升序】
Stream<T> sorted(Comparator<? super T> com);
	对当前 Stream 流存储的进行排序操作，排序规则由 Comparator 函数式接口规范

Stream<T> filter(Predicate<? super T> pre);
	判断过滤当前 Stream 流可以保存的数据条件，满足条件保留，不满足条件移除，过滤规则由 Predicate 接口约束

Stream<T> distinct();
	当前 Stream 流中对应的所有元素去重擦操作

Stream<R> map(Function<T, R> fun);
	当前 Stream 存储的数据情况转换为 Function 函数式接口要求的返回值类型，完成类型转换操作。

Stream 处理数据的【最终方法/终止方法】

终止方法，Stream 流自动关闭。对应 Stream 占用的资源空间会被 JVM 收回

long count();
	返回当前 Stream 流对应的数据元素个数，为终止方法。

void forEach(Consumer<? super T> con);
	针对于当前 Stream 存储元素的处置方法，为终止方法。
	
<R, A> R collect(Collector<? super T, A, R> collector);
	Stream 流对应的元素存储内容，转换为用户要求的 集合对象。终止方法
	常用:
		Collectors.toList() 目标存储集合类型为 List 集合
		Collectors.toSet()  目标存储集合类型为 Set 集合
		
Object[] toArray();
	Stream 流存储的元素内容转换为 Object 类型数组返回

4 相关方法代码演示

4.1 skip 和 limit

list.stream()
    .skip(2) // 跳过当前 Stream 流对应元素的前两个元素
    .limit(8) // 仅保留当前 Stream 流当前的八个元素
    .skip(2)
    .limit(3)
    .forEach(System.out::println);

4.2 sorted

/*
Stream sorted() 排序方法局限性很大，只能用于已经有自然顺序或者遵从 Comparable 接口的
数据类型。
 */
// list.stream().sorted().forEach(System.out::println);
/*
Stream<T> sorted(Comparator<? super T> comparator);
    @FunctionalInterface
    public interface Comparator<T> {
        int compare(T o1, T o2);
    }
当前方法排序所需的条件，排序规则是通过 Comparator 接口提供，数据类型支持
数据排序效果，更好！！！
 */
list.stream()
    .sorted((p1, p2) -> p2.getAge() - p1.getAge())
    .forEach(System.out::println);

4.3 filter

/*
Stream<T> filter(Predicate<? super T> predicate);
    @FunctionalInterface
    public interface Predicate<T> {
        boolean test(T t);
    }
 */
list.stream()
	.filter(s -> s.length() >= 4)
    .distinct()
    .forEach(System.out::println);

4.4 map

/*
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
Lambda 表达式 + Stream 可以利用返回值类型约束泛型。
<R> Stream<R> map(Function<? super String, ? extends R> mapper);
当前 Lambda 表达式返回值结果可以同步约束 R 泛型对应的具体数据类型。
Stream map 方法一般都是通过方法引用引入其他已经完成的功能模块来提升代码效率
在 map 方法中使用 Lambda 完成类型转换，代码效率较低。
 */
Stream<Person> stream = list.stream();
Stream<String> stringStream = stream.map(s -> s.toString());
stringStream.forEach(System.out::println);

4.5 count

Stream<String> stream = list.stream();
long count = stream
        .skip(2)
        .limit(20)
        .skip(5)
        .skip(20)
        .count();
/*
异常信息
stream has already been operated upon or closed
    提示告知当前 Stream 已经被关闭！
 */
stream.forEach(System.out::println);
System.out.println(count);

4.6 collect

// Stream 流数据内容转 List 集合
List<String> list1 = list.stream().distinct().collect(Collectors.toList());
// Stream 流数据内容转 Set 集合
Set<String> set = list.stream().skip(2).limit(20).collect(Collectors.toSet());