这节咱们详细讲一下Stream
/**
* Stream--函数式数据处理
*
* Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行
* 非常复杂的查找、过滤和映射数据等操作。使用Stream API对集合数据进行操作就类似于使用SQL
* 执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Stream API提供了一种
* 高效且易于使用的处理数据的方式。
*
* 1.Stream是个啥
*
* Stream(流)是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。
*
* 集合讲的是数据，流讲的是计算！！！
*
* 1.Stream自己不会存储元素
* 2.Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
* 3.Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
*
* 流操作有两个重要特点：
*
* 1.流水线--很多流操作本身会返回一个流，这样多个操作就可以链接起来，形成一个大的流水线
* 2.内部迭代--与迭代器显示迭代集合不同，流的迭代操作都是在背后进行
*
* 2.Stream的操作三个步骤
*
* 1.创建Stream一个数据源(如：集合、数组)，获取一个流
* 2.中间操作(一个中间操作链，对数据源的数据进行处理，形成一条流的流水线)
* 3.终止操作(一个终止操作，执行中间操作链，并产生结果)
*
* 2.1创建Stream
*
* Java8中的Collection接口被扩展，提供了两个获取流的方法：
*
* default Stream<E> stream():返回一个顺序流
*
* default Stream<E> parallelStream:返回一个并行流
*
* 由数组创建流
*
* Java8中的Arrays的静态方法stream()可以获取数组流：
* static Stream stream(T[] array):返回一个流
*
* 重载形式，能够处理对应基本类型的数组:
*
* public static IntStream stream(int[] array)
* public static LongStream stream(long[] array)
* public static DoubleStream stream(double[] array)
*
* 由值创建流
*
* 可以使用静态方法Stream.of(),通过显示值创建一个流。它可以接收任意数量的参数。
* public static<T> Stream<T> of(T... value):返回一个流
*
* 由函数创建流：创建无限流
*
* 可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流。
*
* 迭代
* public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
*
* 生成
* public static<T> Stream<T> generate(Supplier<T> s)
*
* 2.2.Stream的中间操作
*
* 多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理
* 而在终止操作时一次性全部处理，称为"惰性求值"。
*
* 2.2.1 筛选与切片
*
* 方法 描述
* filter(Predicate p) 接收Lambda，从流中排除某些元素
* distinct() 筛选，通过流所生成元素的hashCode()和equals()去除重复元素
* limit(long maxSize) 截断流，使其元素不超过给定数量
* skip(long n) 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
*
* 2.2.2 映射
*
* 方法 描述
* map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
* mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
* mapToInt(ToIntFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream
* mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream
* flatMap(Function f) 接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
*
* 2.2.3 排序
*
* 方法 描述
* sorted() 产生一个新流，其中按自然顺序排序
* sorted(Comparator comp) 产生一个新流，其中按比较器顺序排序
*
* 2.3 Stream的终止操作
*
* 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如List、Integer，甚至是void
*
* 2.3.1 查找与匹配
*
* 方法 描述
* allMatch(Predicate p) 检查是否匹配所有元素
* anyMatch(Predicate p) 检查是否至少匹配一个元素
* noneMatch(Predicate p) 检查是否没有匹配所有元素
* findFirst() 返回第一个元素
* findAny() 返回当前流中的任意元素
* count() 返回流中的元素总数
* max(Comparator c) 返回流中的最大值
* min(Comparator c) 返回流中的最小值
* forEach(Consumer c) 内部迭代(使用Collection接口需要用户去做迭代，称为外部迭代。
* 相反，Stream API使用内部迭代即不需要用户去实现迭代)
* 2.3.2 规约
*
* 方法 描述
* reduce(T iden,BinaryOpenrator b) 可以将流中元素反复结合起来，得到一个值。返回T
* reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回Optional<T>
*
* 2.3.3 收集
*
* 方法 描述
* collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
*
* Collectors
*
* Collector接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。但是Collectors实用类
* 提供了很多静态方法，可以方便的创建常见收集器实例，如下表：
*
* 方法 返回类型 作用 示例
* tolist List 把流中元素收集到List List list=list.stream()
* .collect(Collectors
* .toList());
* toSet Set 把流中元素收集到Set Set set=list.stream()
* .collect(Collectors
* .toSet());
* toCollection Collection 把流中元素收集到创建的集合 Collection maps=list.stream()
* .collect(Collectors
* .toCollection(ArrayList::new));
* counting Long 计算流中元素的个数 long count=list.stream()
* .collect(Collectors
* .counting());
* summingInt Integer 对流中元素的整数属性求和 Integer sum=persons.stream()
* .collect(Collectors
* .summingInt(Person::getAge));
* averagingInt Double 计算流中元素Integer属性 double avg=list.stream()
* 的平均值 .collect(Collectors
* .averagingInt(Person::getAge));
* summarizingInt IntSummary- 收集流中Integer属性 IntSummaryStatistics iss= list.stream()
* -Statistics 的统计值.如：平均值 .collect(Collectors
* .summarizingInt(Person::getAge));
* joining String 连接流中每个字符串 String str=list.stream()
* .map(Person::getName)
* .collect(Collectors.joining());
* maxBy Optional<T> 根据比较器选择最大值 Optional max=list.stream()
* .collect(Collectors
* .maxBy(comparingInt(Person:getAge)));
* minBy Optional<T> 根据比较器选择最小值 Optional min=list.stream()
* .collect(Collectors
* .minBy(comparingInt(Person:getAge)));
* reducing 规约产生的类型 从一个作为累加器的初始值开始， int total=list.stream()
* 利用BinaryOperator与流中 .collect(Collectors
* 元素逐个结合，从而规约成单个值 .reducing(0,Person::getAge,Integer::sum))
* collecting- 转换函数返回的类型 包裹另一个收集器，对其结果 int how=list.stream()
* -AndThen 转化函数 .collect(Collectors
* .collectingAndThen(Collectors.toList(),List::size))
* groupingBy Map<K,List<T>> 根据某属性值对流分组，属性为K, Map<Person.Sex,List<Person>>
* 结果为V map=persons.stream().collect(Collectors
* .groupingBy(Person:;getGender))
* partitioningBy Map<Boolean 根据true或false进行分区 Map<Boolean,List<Person>>
* ,List<T>> map=persons.stream().collect(Collectors
* .partitioningBy(e -> e.getAge()>=50))
* 3.并行流与串行流
*
* 先说说并行和并发
*
* 并发是两个任务共享时间段，并行则是两个任务在同一时间发生，比如运行在多核CPU上。
*
* 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
*
* Java8中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API可以声明性的通过
* parallel()与sequential()在并行流与顺序流之间进行切换。如果想从一个集合类创建一个流，
* 调用parallerStream就可以获取一个并行流。
*
* 配置并行流使用的线程池
*
* 使用流的parallel方法你会想到，并行流用的线程是从哪儿来的？有多少个？怎么自定义？
*
* 并行流内部使用默认的ForkJoinPool(分支/合并框架)，它默认的线程数量就是你的处理器数量，
* 这个值是由Runtime.getRuntime().availableProcessors()得到
*
* 你可以通过系统属性java.util.concurrent.ForkJoinPool.common.parallelist
* 来改变线程池大小，如下：
* System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism","12");
* 这是一个全局设置，因此会影响代码中所有的并行流
* （目前还无法专门为某个并行流指定该值，一般而言，
* 让ForkJoinPool的大小等于处理器数量是个不错的默认值）
*
* 高效使用并行流
*
* 1.并行流并不是总比顺序流快
* 2.留意装箱。自动装箱和拆箱操作会大大降低性能，Java8中有原始类型流(IntStream、LongStream...)
* 来避免这种操作
* 3.有些操作本身在并行流上的性能就比顺序流差，特别是limit和findFirst等依赖元素顺序的操作，
* 他们在并行流上执行的代价就非常大
* 4.还要考虑流的操作流水线的总计算成本
* 5.对于较小的数据量，没有必要使用并行流
* 6.要考虑流背后的数据结构是否易于分解，比如：ArrayList的拆分效率比LinkedList高很多，前者无需遍历
* 7.还要考虑终端操作中合并步骤的代价是大是小(如：Collector中的combiner方法)
*
* 4.Fork/Join框架
*
* 并行流背后使用的基础框架就是Java7中引入的分支/合并框架。
*
* Fork/Join(分支/合并)框架的目的是以递归方式将可以并行的任务拆分(fork)成更小的任务，
* 然后将每个任务的结果合并(join)起来生成整体效果，它是ExectorService接口的一个实现，
* 把子任务分配给线程池(称为ForkJoinPool)中的工作线程
*
* Fork/Join框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务(拆到不可再拆时)，
* 再将一个个的小任务的运算的记过进行join汇总
*
*
* Fork/Join框架与传统线程池的区别
*
* 1.采用"工作窃取"模式(work-stealing):当执行新的任务时，它可以将其拆分成更小的任务执行，
* 并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。
* 2.相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上，在一般的
* 线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态，而在
* fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续进行，那么处理该
* 子问题的线程会主动寻找其他尚未运行的子问题来执行，这种方式减少了线程的等待时间，提高了性能。
*
* 使用Fork/Join框架的最佳做法
*
* 1.对一个任务调用join方法会阻塞调用方，知道该任务作出结果。因此，有必要在两个子任务的计算
* 都开始之后再调用它
* 2.不应该在RecursiveTask内部使用ForkJoinPool的invoke方法。相反，你应该始终直接调用
* compute或fork方法，只有顺序代码才应该用invoke来启动并行计算
*
* 5.Spliterator
*
* "可分迭代器" --spliterator，和Iterator一样，也用于遍历数据源中的元素，
* 它是为了并行执行而设计的。
*
* Java8为集合框架中 包含的所有数据结构都提供了一个默认的Spliterator方法。
* 集合实现了Spliterator接口，接口提供了一个Spliterator方法。
*
* */
public class StreamInfo {
//创建Stream
@Test
public void test(){
//1.Collection 提供了两个方法 stream()与parallelStream()
List<String> list = new ArrayList<String>();
Stream<String> stream = list.stream();
Stream<String> paralleStream = list.parallelStream();
//2.通过Arrays中的stream()获取一个数组流
Integer[] nums = new Integer[10];
Stream<Integer> stream1 = Arrays.stream(nums);
//3.通过Stream类中的静态方法of（）
Stream<Integer> Stream2 = Stream.of(1,2,3);
//4.创建无限流
//迭代 其中iterate(final T seed, final UnaryOperator<T> f)
// 接口UnaryOperator继承了Function
// 功能是：对数据进行操作，生成一个与同类型对象
Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
stream3.forEach(p -> System.out.println(p));
//生成 其中generate(Supplier<T> s)
// 参数Supplier接口为一个提供者用于创建对象的工厂，可以这么理解吧
Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
stream4.forEach(System.out::println);
}
//生成多个Person对象
List<Person> persons = Person.createRoster();
//内部迭代：迭代操作Stream API内部完成
@Test
public void test2(){
Stream<Person> stream = persons.stream()
.filter(
p -> {
System.out.println("测试中间操作");
return p.getAge() <=35;
}
);
//只有当做终止操作时，所有的中间操作才会一次性的全部执行
stream.forEach(System.out::println);
}
//外部迭代
@Test
public void test3(){
Iterator<Person> it = persons.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
@Test
public void test4(){
persons.stream()
.filter(p -> {
System.out.println("大于25岁成员：");
return p.getAge()>=25;
}).limit(3)
.forEach(p -> System.out.println(p));
}
@Test
public void test5(){
persons.parallelStream()
.filter(p -> p.getAge()>=25)
.skip(2)
.forEach(System.out::println);
}
@Test
public void test6(){
persons.stream()
.distinct()
.forEach(System.out::println);
}
/**
* 映射
* */
@Test
public void test7(){
Stream<String> str = persons.stream()
.map(e -> e.getName());
System.out.println("---------------------------------");
List<String> strList = Arrays.asList("aaa","bbb","ccc","ddd","eee");
Stream<String> stream = strList.stream().map(p -> p.toUpperCase());
// Stream<String> stream = strList.stream().map(String::toUpperCase);
stream.forEach(p -> System.out.println(p));
// stream.forEach(System.out::println);
System.out.println("---------------------------------");
Stream<Character> stream2 = strList.stream()
.flatMap(StreamInfo::filterCharacter);
// Stream<Character> stream3 = strList.stream()
// .flatMap(s -> StreamInfo.filterCharacter(s));
stream2.forEach(System.out::print);
}
public static Stream<Character> filterCharacter(String str){
List<Character> list = new ArrayList<>();
for (Character ch : str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
}源码下载地址：https://download.csdn.net/download/qq_20410965/12434193