流的操作分类

1. 创建流操作

   从一个数据源（如集合、数组）中获取一个流

2. Intermediate(中间) 操作

   在流后面可以跟0到N个中间操作，其存在的目的是对流的数据进行过滤和映射，然后返回一个新的流，交给下一个操作使用；这类操作都是惰性（lazy）的，也就是说，当调用到这类方法时，其实并未开始流的遍历操作。

3. terminal（终结）操作

   在整个流生命周期内只内进行一次，且不可逆转的操作；
   当这类操作执行之后，流就被完全使用了，不可以再进行其他操作，所以这类操作的使用必定是最后一个流操作。terminal操作的执行，才会真正的开始流的遍历，并且产生一个结果。或者导致一个副作用（side effect）

创建流

从集合创建流

Java8 中的 Collection 接口被扩展了，提供了两个获取流的方法：

• default Stream stream() : 返回一个顺序流
• default Stream parallelStream() : 返回一个并行流

List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

从数组创建流

Java8 中的 Arrays 的静态方法 stream() 可以从数组获取流：

• static Stream stream(T[] array): 返回一个流

  String[] nums = new String[8];
  Stream<String> stream = Arrays.stream(nums);

从静态方法创建流

可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数

• public static Stream of(T… values) : 返回一个流

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

IntStream intStream = IntStream.of(new int[]{1,2,3});
IntStream.range(1,3).forEach(System.out::print); // 不包含最大值
IntStream.rangeClosed(1,3).forEach(System.out::print); // 包含最大值
DoubleStream doubleStream = DoubleStream.of(new int[]{1.2d,2.3d,3.4d});

### 从函数创建流

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。
* public static Stream iterate(final T seed, final UnaryOperator f)
* public static Stream generate(Supplier s) 

Stream.iterate(1, (x) -> x + 1).forEach(System.out::println);
Stream.generate(() -> Math.random()).forEach(System.out::println);

### 流转换为其他数据结构

Stream stream = Stream.of("a", "b", "c");
// 转换为数组
String[] strings = (String[]) stream.toArray(String[]::new);
// 转换为集合List
List<String> list1 = (List<String>) stream.collect(Collectors.toList());
// 转换为集合List的子类ArrayList
List<String> list2 = (List<String>) stream.collect(Collectors.toCollection(ArrayList::new));
// 转换为集合Set
Set set1 = (Set) stream.collect(Collectors.toSet());
// 转换为栈
Stack stack1 = (Stack) stream.collect(Collectors.toCollection(Stack::new));
//转换为字符串
String str = stream.collect(Collectors.joining(",")).toString();

## Intermediate(中间操作)

在创建出流以后，我们就可以进行中间操作了。多个中间操作可以连接起来形成一个流水线，除非流水线上触发terminal(终止)操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性（lazy）求值”

中间操作按照使用功能划为又可以分为四类
*  筛选
*  切割
*  排序
*  映射

按照操作数据的状态又可以分为两类
*  有状态      -- 元素的处理不受之前元素的影响
*  无状态      -- 该操作只有拿到所有元素之后才能继续下去

### 筛选
Stream中进行筛选操作有两个方法
#### Stream<T> filter(Predicate<? super T> predicate);  

List<User> users = new ArrayList<>();
users.add(new User("zhangsan",18,""));
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));

筛选年龄大于18岁的用户，并进行循环输出
users.stream()
.filter(user->user.getAge()>18)
.forEach(System.out::println);

####  Stream<T> distinct();   
根据流所生成元素的 hashCode() 和 equals() 去除重复元素

User user = new User("zhangsan",18,"");
users.add(user);
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
users.add(user);

// 输出全部用户
users.stream().forEach(System.out::println);
// 输出去重后的全部用户
users.stream().distinct().forEach(System.out::println);

### 切割

Stream 中对流的切割也有两种切割方法,limit()从0开始到maxSize切割流，  skip() 从指定位置开始切割至流末尾。

#### Stream<T> limit(long maxSize); 
截取元素长度不大于maxSize的元素，组成一个新的Stream.

Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6,7,8,9,0);
integerStream.limit(5).forEach(System.out::println);

#### Stream<T> skip(long n); 
丢弃流的前n个元素，如果流所包含的元素少于n个，那么返回一个空的stream.

Stream<Integer> integerStream = Stream.of(1,2,3,4,5,6,7,8,9,0);
integerStream.skip(5).forEach(System.out::println);

### 排序

Stream 对排序有两种方法

#### Stream<T> sorted();  
按照自然顺序排序,如果流元素不是Comparator的，则当执行Terminal操作的时候将抛出类型转换异常ava.lang.ClassCastException

Stream<Integer> integerStream = Stream.of(20,2,30,12,70);
integerStream.sorted().forEach(System.out::println);

#### Stream<T> sorted(Comparator<? super T> comparator);    
根据提供的Comparator 进行排序，源码中说，对于顺序流，排序是稳定的，对于无序流，不保证排序的稳定性

List<User> users = new ArrayList<>();
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
users.stream().sorted(Comparator.comparing(User::getAge)).forEach(System.out::println);

### 映射

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

List<User> users = new ArrayList<>();
users.add(new User("lisi",26,""));
users.add(new User("米酒",40,""));
users.add(new User("郝十",18,""));
users.stream().map(User::getName).forEach(System.out::println);

Stream<Integer> integerStream = Stream.of(20,2,30,12,70);
integerStream.map(w->w*10).forEach(System.out::println);

**IntStream mapToInt(ToIntFunction<? super T> mapper);  返回一个IntStream映射**   
**LongStream mapToLong(ToLongFunction<? super T> mapper);  返回一个LongStream映射**   
**DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper); 返回一个DoubleStream映射**   
与map()方法类似，只不过返回的是对应封装类型的Stream

####  <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
多个流整合成一个流,把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一起，最终 output 的新 Stream 里面已经没有 List 了

List<Integer> list1 = Arrays.asList(1,2,3);
List<Integer> list2 = Arrays.asList(4,5,6);
List<Integer> list3 = Arrays.asList(7,8,9);
List<List<Integer>> target = new ArrayList<>();
target.add(list1);
target.add(list2);
target.add(list3);
// 原流输出
System.out.pringln("原流输出");
target.stream().forEach(System.out::println);
// 整合流之后输出
System.out.pringln("整合流输出");
target.stream().flatMap((item)-> item.stream()).forEach(System.out::println);

>原流输出
>[1, 2, 3]  
>[4, 5, 6]  
>[7, 8, 9]  
>整合流输出
>1  
>2  
>3  
>4  
>5  
>6  
>7  
>8  
>9  

**IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);**   
**LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);**   
**DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);   **  
同map方法的其他封装类的使用方法是一样的，同样只是返回结果为封装类对应的Stream   

## 终止操作

 终止操作会从流的中间操作流水线生成结果。其结果可以是任何不是流的值，例如： `List`、 `Integer`，甚至是 `void` 。 

其中终止操作又分为三类

* 查找与匹配
* 规约
* 收集

### 查找与匹配

查找与匹配有很多方法，具体如下

```java
void forEach(Consumer<? super T> action);     // 内部循环流的元素
void forEachOrdered(Consumer<? super T> action);    // 内部有序循环流的元素
boolean anyMatch(Predicate<? super T> predicate);    // 任意匹配  返回boolean值
boolean allMatch(Predicate<? super T> predicate);    // 全匹配 返回boolean值
boolean noneMatch(Predicate<? super T> predicate);      // 全不匹配 返回boolean值
Optional<T> findFirst();           // 查找第一个元素 
Optional<T> findAny();            // 查找任意元素
Optional<T> min(Comparator<? super T> comparator);    // 查找最小（按参数指定的规则）
Optional<T> max(Comparator<? super T> comparator);    // 查找最大元素（按参数指定的规则）
long count();             // 统计元素数量

forEach() 与forEachOrdered()的区别

List<String> list = Arrays.asList("a","c","b");
list.stream().forEach(System.out::print);           // acb
System.out.println();
list.stream().forEachOrdered(System.out::print);    // acb
System.out.println();
list.parallelStream().forEach(System.out::print);   // cba  
System.out.println();
list.parallelStream().forEachOrdered(System.out::print);    // acb

串行流的情况下，两种方法都能够按照顺序进行内部循环，

但是在并行流的情况下forEach()的顺序就得不到保证了，有可能是按顺序的，有可能是任意顺序的。如上输出结果

anyMatch()

boolean anyMatch(Predicate<? super T> predicate);

匹配流中是否有元素与提供的谓语相匹配，如果流为空，返回false

List<String> list = Arrays.asList("a","c","b");
boolean result = list.stream().anyMatch(item -> item.equals("c"));
System.out.println(result);     // true

代码中匹配是否含有等于"c"的元素

findFirst()

返回流的第一个元素的，如果流为空，则返回一个空的。如果流是无序的话，则可能返回任一元素。

Optional<T>是什么？

optional<T> 是一个可以包含为空或者非空对象的对象容器，如果对象有值，则 isPresent() 返回true，get()方法返回该对象的值。

 List<String> list = Arrays.asList("a","c","b");
 System.out.println(list.stream().findFirst().get());  // a

count

返回此流中的元素个数

 List<String> list = Arrays.asList("a","c","b");
 System.out.println(list.stream().count());     // 3

归约（简化）

Optional<T> reduce(BinaryOperator<T> accumulator);
T reduce(T identity, BinaryOperator<T> accumulator);   // identity  初始值，
<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

使用实例：

String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
System.out.println(concat);            // ABCD
Integer sum = Stream.of(1, 2, 3, 4).reduce(10, Integer::sum);
System.out.println(concat);  // 20

// 以下代码转载自：https://segmentfault.com/q/1010000004944450
//accumulator不写入list,不需要线程同步,初始值使用普通的list
List<Integer> list = new ArrayList<>();
AtomicInteger accumulateCount = new AtomicInteger(0);
AtomicInteger combineCount = new AtomicInteger(0);
List<Integer> reduceResult = IntStream.range(0, 100).parallel().boxed()
                .reduce(list, (i, j) -> {
                    accumulateCount.incrementAndGet();
                    //不改变初始的i,而是返回一个新的i
                    ArrayList<Integer> newI = new ArrayList<>(i);
                    newI.add(j);
                    return newI;
                }, (i, j) -> {
                    combineCount.incrementAndGet();
                    System.out.println(String.format("i==j: %s, thread name:%s", i == j, Thread.currentThread().getName()));
                    ArrayList<Integer> newI = new ArrayList<>(i);
                    newI.addAll(j);
                    return newI;
                });
        System.out.println("---------------------------------------");
        System.out.println("reduce result size: "+reduceResult.size());
        System.out.println("reduce result : "+reduceResult);
        System.out.println("accumulateCount: "+accumulateCount.get());
        System.out.println("combineCount: "+combineCount.get());

收集

<R> R collect(Supplier<R> supplier,
                  BiConsumer<R, ? super T> accumulator,
                  BiConsumer<R, R> combiner);    // 简化调用，并发模式下结果可能会不一样
<R, A> R collect(Collector<? super T, A, R> collector);   // 高级调用

代码示例

StringBuffer array =  Lists.newArrayList("1", "2", "3", "4", "5")
                .stream()
                .collect(StringBuffer::new, (x,y)->x.append(y), (a1, a2) -> a1.append(",").append(a2));    //  12345