----------------------------

JAVA8新特性-Stream接口 |

----------------------------

* Stream 接口(果然是新东西,连Editplus都没标红提示)

* 它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。

* 通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序

* Stream 的另外一大特点是，数据源本身可以是无限的。

* 它并非是数据结构,也不是容器.而是一个过程

* 流的操作分为两种

Intermediate

* 一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy）

* 就是说，仅仅调用到这类方法，并没有真正开始流的遍历。

* 方法

map (mapToInt, flatMap 等)、

filter

distinct

sorted

peek

limit

skip

parallel

sequential

unordered

Terminal

* 一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。

* Terminal 操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect。

* 方法

forEach

forEachOrdered

toArray

reduce

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

iterator

* 如果一个流的操作,没有 Terminal ,则该流中的任何 Intermediate 操作都不会执行

----------------------------

JAVA8新特性-Stream的获得 |

----------------------------

1,Collection 子类创建

* 子类直接调用 stream();方法(常用)

* 子类直接调用 parallelStream();方法,定义在 Collection 接口中的 default 方法

2,数组创建

* Arrays.stream(T[] array);

4,Stream 静态方法创建

* Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6);

5,文件IO创建

* Stream<String> stream = Files.lines(String path,Charset charser);

* 该流会自动关闭

# 创建无限流的方法

* Stream<T> str = Stream.generate(Supplier<T> supplier);

* 该流每次执行 foreach 都会调用 supplier 的 get 方法,也就是说该构建方法可以创建无限大的流

* Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);

* 先获取一个无限长度的正整数集合的Stream，然后取出前10个打印。千万记住使用limit方法，不然会无限打印下去。

----------------------------

JAVA8新特性-Stream接口方法 |

----------------------------

parallel();

* 启用并行流

filter (Predicate<? super T> predicate);

* 用于过滤,筛选

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

* 对于Stream中包含的元素使用给定的转换函数进行转换操作,把所有的返回值,组成新的流

* '传入个User对象(User流),提取里面的所有name属性,转换为一个Stream的流'

* 新生成的Stream只包含转换生成的元素。

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

* 传入的就是流,

* 和map类似，不同的是传入的元素,就是一个流

* 说白了,就是传入的每一个流,然后合并起来成为一个流,返回

* 注意参数对象 Function 的返回值是 Stream

mapToInt

mapToLong

mapToDouble

* 这三个都是一样的,计算后的新的流是指定值类型(IntStream,LongStream,DoubleStream)可以免除自动装箱/拆箱的额外消耗；

sorted ();

* 也是排序,需要元素自身实现 Comparable 接口

sorted (Comparator<? super T> comparator);

* 排序,自定义 Comparator 来完成排序

peek (Consumer<? super T> action);

* 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；

* 跟 map 的区别就是,map是创建新的返回,这个不返回直接在原来的上改

limit (long maxSize);

* 返回流前面的几个元素,如果原Stream中包含的元素个数小于N，那就获取其所有的元素

* 也可以用在 Set 集合的流上,那么截取到的流,是无序的

skip (long n);

* 丢弃(跳过)流前面的几个元素,如果原Stream中包含的元素个数小于N，那么返回空Stream；

forEach (Consumer<? super T> action);

* 遍历,在多核情况下也许会失去顺序

* 如果你需要多核遍历,那么需要调用 arr.parallelStream().forEach(System.out::println); 'Collection' 接口的默认方法

forEachOrdered (Consumer<? super T> action);

* 同上,但是,'在多核情况下顺序不会有影响'

reduce (T identity, BinaryOperator<T> accumulator);

* 第一个参数是初始值,后面 Lambda传递俩值.表示要进行啥操作,得到啥结果

* int sum = numbers.stream().reduce(0,(a,b) -> {a + b}); //求一组集合中所有数字的和

* 如果是 parallelStream(); 并行流调用执行的话,传递给 Lambda 表达式 accumulator 的俩变量不能更改状态,而且操作必须满足结合律才可以按任意顺序执行

reduce ();

* 上面的重载,无初始值

* 返回 Optional<T>,因没初始值.怕流是空的

* Optional<Integer> max = numbers.stream().reduce(Integer::max); //返回数字流中的最大值

toArray ();

* 返回 Object[] 数组

findFirst ();

* 这是一个 termimal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素，或者空。

findAny

* 同上,也是返回第一个元素.但是这个牛逼之处在于,'处理并行'.

* 如果你不介意返回的元素是哪个,可以使用这个

distinct ();

* 去除重复,会依赖hashCode和equals

count ();

* 返回流中元素的个数

min(Comparator com);

* 根据比较器,获取最的元素

max(Comparator com);

* 根据比较器,获取最大的元素

collect(Collectors.toList());

* 把结果,转换为一个集合

* 接收一个 Collectors 接口的实现,用于把元素中的内容,进行一个汇总

//匹配系列的API

allMatch

* 检查是否匹配所有元素,返回 boolean

anyMatch

* 检查是否至少匹配一个元素 boolean

noneMath

* 检查是否未匹配中任何元素 boolean

findFirst

* 返回第一个元素

* 返回是的类型是 Optional

findAny

* 返回当前流中的任意元素

* 返回是的类型是 Optional

----------------------------

JAVA8新特性-基本数据类型的 |

----------------------------

* 对于基本数值型，目前有三种对应的包装类型 Stream：

IntStream

LongStream

DoubleStream

* 当然我们也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是拆箱和装箱会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。

* 额外方法

min(); //获取流中的最小值

max(); //获取流中的最大值

sum(); //和值

average(); //平均值

boxed(); //转换会 Stream<T> 流

----------------------------

JAVA8新特性-无限流 |

----------------------------

# 迭代

Stream.iterate(0, n -> n+2);

* 0 表示初始值,然后不断的 +2

* 一般来说说,需要依次生成一系列值的时候就应该用这个

# 生成

Stream<T> str = Stream.generate(Supplier<T> supplier);

* 该流每次执行 foreach 都会调用 supplier 的 get 方法,也就是说该构建方法可以创建无限大的流

----------------------------

JAVA8新特性-流的状态 |

----------------------------

# 无状态

# 有状态 -> 有界

# 有状态 -> 无界

----------------------------

JAVA8新特性-并行流 |

----------------------------

# 多线程的流

* 通过 parallelStream(); 可以获取多线程的流

list.parallelStream().forEach(System.out::println); //多线程打印,顺序会有影响

* 流直接调用 parallel(); 方法

Stream<String> stream = Stream.of("1","2","4").parallel();

Stream<String> stream = Stream.of("1","2","4").parallel();

return user.getAge() > 20 ? "中年" : "青年";

return user.getAge() > 20 ? "中年" : "青年";

}));

Collectors.joining();

* 连接操作,字符串连接.没有任何中间符号

* Demo

String namesss = users.stream()

.map(User:getName);

.collect(Collectors.joining());

Collectors.joining(String a,String b,String c);

* 同上,不过会在连接的开头加上 b,结尾加上 c,每个连接点之间加上 a