Java8特性-Stream流

1.Stream流的执行流程

1. 先得到一条stream流 并把数据放上去
2. 利用stream流中的API进行各种过滤操作
3. 使用终结方法对stream流上的数据进行操作

2.Stream流使用步骤

获取方式	方法名	说明
单列集合	default Stream<E> stream	Collection中的默认方法
双列集合	无	无法直接使用Stream流，可以转换为keySet或者EntrySet使用
数组	public static<T> Stream<T> stream(T[] array)	Arrays工具类中的静态方法
零散数据	public static<T> Stream<T> of(T... values)	stream接口中的静态方法

实例：

public static void main(String[] args) {
        //使用流处理打印字符  单列集合
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");
        list.forEach(System.out::println);

        //使用流处理打印字符  双列集合
        HashMap<String, Integer> map = new HashMap<>();
        map.put("aaa",111);
        map.put("bbb",112);
        map.put("ccc",113);
        map.put("ddd",114);
        map.put("eee",115);
        //使用流打印
        // 第一种
        map.keySet().forEach(System.out::println);
        /*
        aaa
        ccc
        bbb
        eee
        ddd
         */
        // 第二种
        map.entrySet().forEach(System.out::println);
        /*
        aaa=111
        ccc=113
        bbb=112
        eee=115
        ddd=114
        */
        //使用流处理打印字符  数组
        int[] arr = {1,2,3,4,5,9,6,7,8};
        Arrays.stream(arr).forEach(System.out::println);

        //使用流处理打印字符  零散数据
        Stream.of("hello",2,34,56,"but",23,4).forEach(System.out::println);
    }

Stream.of()传递基本数据类型数组时会将整个数组作为一个参数放到数组当中。

2.stream流的中间方法

名称	说明
Stream<T> filter(Predicate<? super T> predicate)	过滤
Stream<T> limit (long maxSize)	获取前几个元素
Stream<T> skip(long n)	跳过前几个元素
Stream<T> distinct()	元素去重，依赖（hashCode和equals方法）
static<T> Stream<T> concat(Stream a , stream b)	合并a和b两个流为一个流，如果流中数据类型不一样，合并流中数据类型是他们的父类
Stream<R> map(Function<T,R> mapper)	转换流中的数据类型

1.中间方法会返回新的stream流对象，原来的stream流只能使用一次，建议使用链式编程。

2.修改stream流中的数据，不会影响原来集合或者数组中的数据。

示例

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"孙武-500","吴起-400","吴起-400","吴起-400","孙膑-500","乐毅-232","韩信-323","白起-212","王翦-123","卫青-56","霍去病-67","李靖-500",
                "李靖-500","李積-423","吴起-500","李世民-600","苏烈-700","李晟-800","王忠嗣-852","岳飞-999","成吉思汗-1056","徐达-1433");
        //过滤
        //筛选姓李  lambda表达式
        list.stream().filter(name -> name.startsWith("李")).forEach(System.out::println);
        //名字长度大于等于三
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>=3;
            }
        }).forEach(System.out::println);

        //limit 获取前几个元素
        list.stream().limit(3).forEach(System.out::println); //获取前三个元素

        //跳过
        list.stream().skip(4).forEach(System.out::println);//跳过前四个元素

        //distinct 去重
        list.stream().distinct().forEach(System.out::println);

        //合并流 concat
        Stream.concat(list.stream().filter(s->s.startsWith("王")), list.stream().distinct().filter(s->s.startsWith("李"))).forEach(System.out::println);
        
        //map 数据类型转换 以一个求和示例为例
        int sum = 0;
        sum = list.stream().map(s -> Integer.parseInt(s.split("-")[1])).reduce(0,Integer::sum);
        System.out.println(sum);
    }

3.stream流的终结方法

名称	说明
void forEach(Consumer action)	遍历
long count()	统计
toArray()	收集流中的数据，放到数组中
collect(Collector collector)	收集流中的数据，放到集合中

示例：

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "孙武-500", "吴起-400", "吴起-400", "吴起-400", "孙膑-500", "乐毅-232", "韩信-323", "白起-212", "王翦-123", "卫青-56", "霍去病-67", "李靖-500",
                "李靖-500", "李積-423", "吴起-500", "李世民-600", "苏烈-700", "李晟-800", "王忠嗣-852", "岳飞-999", "成吉思汗-1056", "徐达-1433");
        //forEach
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s.split("-")[0] + " " + s.split("-")[1]);
            }
        });
        //count
        long sum = list.stream().distinct().count();
        //toArray
        String[] objects = list.stream().toArray(value -> new String[value]);
        String[] names = list.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });

        //Collect
        //list
        List<String> 李 = list.stream().filter(s -> s.startsWith("李")).collect(Collectors.toList());
        //set
        Set<String> 孙 = list.stream().filter(s -> s.startsWith("孙")).collect(Collectors.toSet());
        //map
        Map<String, String> 王 = list.stream()..distinct().filter(s -> s.startsWith("王")).collect(Collectors.toMap(s -> s.split("-")[0], s -> s.split("-")[1]));
    }