Stream流（jdk新特性）

Stream流

java8，通过Lambda表达式引入

获取流对象

java.util.stream.Stream是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）

获取一个流非常简单，有以下几种常用的方式：
- 所有的Collection集合都可以通过stream默认方法获取流；
- java.util.Map接口不是Collection的子接口，且其K-V数据结构不符合流元素的单一特征，所以获取对应的流需要分key、value或entry等情况：
- Stream接口的静态方法of可以获取数组对应的流。

### ==通过Collection集合获取流对象==
- 首先，java.util.Collection接口中加入了default方法stream用来获取流，所以其所有实现类均可获取流。



public class Collection2Stream(){
    //collection集合
    Collection c = new Collection();
    Stream stream1 = c.stream();

    //List集合
    List<String> list = new ArrayList<>();
    Stream<String> stream2 = list.stream();

    //Set集合
    Set<String> set = new HashSet<>();
    Stream<String> stream3 = set.stream();

    //Map集合
    HashMap<String,String> map = new HashMap<>();
    //1.keyset集合
    Stream<String> stream1 = map.keySet().stream();
    //2. values
    Stream<Integer> stream2 = map.values().stream();
    // 3. entrySet
    Stream<Map.Entry<String, Integer>> stream3 = map.entrySet().stream();

}

根据Map获取流



public class Map2Stream(){

    //Map集合
    HashMap<String,String> map = new HashMap<>();
    //1.keyset集合
    Stream<String> stream1 = map.keySet().stream();
    //2. values
    Stream<Integer> stream2 = map.values().stream();
    // 3. entrySet
    Stream<Map.Entry<String, Integer>> stream3 = map.entrySet().stream();

}

根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以Stream接口中提供了静态方法of，使用很简单：

public class Array2Stream(){


    String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };

    // Stream 类的静态方法 : of
    Stream<String> stream = Stream.of(array);
    System.out.println("stream = " + stream);

}

Stream流的常用API

在上述介绍的各种方法中，凡是返回值仍然为Stream接口的为函数拼接方法，它们支持链式调用；而返回值不再为Stream接口的为终结方法，不再支持链式调用。如下表所示：

方法名	方法作用	方法种类	是否支持链式调用
count	统计个数	终结	否
forEach	逐一处理	终结	否
filter	过滤	函数拼接	是
limit	取前几个	函数拼接	是
skip	跳过前几个	函数拼接	是
map	映射	函数拼接	是
contact	组合	函数拼接	是

流API的使用

逐一处理：forEach

void forEach(Consumer

统计个数：count

返回值为long类型

void forEach(Consumer<? super T> action);
该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。例如：

import java.util.stream.Stream;

public class Test1 {
    public static void main(String[] args) {

        Stream<String> stream = Stream.of("张无忌", "张学友", "刘德华", "张三丰");

        // void forEach(Consumer<? super T> action);
        stream.forEach(System.out::println);
        //返回值为long
        long count = stream.count();
    }
}

过滤：filter

Stream filter(Predicate

取前几个：limit

Stream limit(long maxSize);

跳过前几个：skip

Stream skip(long n);

public class Test1 {
    public static void main(String[] args) {

        Stream<String> stream = Stream.of("张无忌", "张学友", "刘德华", "张三丰");

        stream.filter(name->name.startsWith("张"))
              .limit(2)
              .forEach(System.out::println);

    }
}

映射：map

- `<R> Stream<R> map(Function<? super T, ? extends R> mapper);`
- 该接口需要一个Function函数式接口参数，可以将当前流中的 T 类型数据转换为另一种 R 类型的流。

import java.util.stream.Stream;

public class Test1 {
    public static void main(String[] args) {

        Stream<String> stream = Stream.of("10", "20", "30", "40", "50");

        // <R> Stream<R> map(Function<? super T, ? extends R> mapper);
        // Function 接口 : R apply(T t);
        stream.map(Integer::parseInt).forEach(System.out::println);
    }
}

组合：concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat：
- static Stream concat(Stream

import java.util.stream.Stream;

public class Test2 {
    public static void main(String[] args) {

        Stream<String> stream1 = Stream.of("刘德华", "张学友", "黎明", "郭富城");
        Stream<String> stream2 = Stream.of("西施", "杨玉环", "貂蝉", "王昭君");

        Stream<String> stream = Stream.concat(stream1, stream2);
        stream.forEach(System.out::println);
    }
}