Stream流

Stream流

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

对比：

package com.py.Stream;

import java.util.ArrayList;
import java.util.List;

public class DemoStreamFilter {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("霍元甲");
        list.add("张无忌");
        list.add("杨过");
        list.add("张文");
//      过滤获得一张开头的名字
        ArrayList<String> nlist = new ArrayList<>();
        for (String i :
                list) {
            if (i.startsWith("张")){
                nlist.add(i);
            }
        }

//      循环得到字符长度为3的名字
        for (String i :
                nlist) {

            if (i.length()==3){
                System.out.println(i);
            }
        }
    }
}

package com.py.Stream;

import java.util.ArrayList;

public class DemoStreamFilter01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("霍元甲");
        list.add("张无忌");
        list.add("杨过");
        list.add("张文");
        //      过滤获得一张开头的名字
        //      循环得到字符长度为3的名字
        //      遍历
        list.stream()
                .filter(name->name.startsWith("张"))
                .filter(name->name.length()==3)
                .forEach(naem-> System.out.println(naem));
    }
}

获取Stream流的方法

• 所有的Collection集合（单列集合）都可以通过Strem方式获得流

  • java.util.Interface Collection

  ​ default Stream stream() 返回以此集合作为源的顺序 Stream 。

• Stream接口的静态方法of可以获得数组对应的流

  • java.util.stream.Interface Stream

集合间的关系

实例

package com.py.Stream;

import java.util.*;
import java.util.stream.Stream;

public class DemoGetStream {
    public static void main(String[] args) {
        //把ArraryList转换为流
        ArrayList<String> list = new ArrayList<>();
        Stream<String> stream01 = list.stream();

        //将set转化为流
        Set<String> set = new HashSet<>();
        Stream<String> stream02 = set.stream();

        //Map转化为stream流
        Map<String,String> map = new HashMap<>();
            //将键转化为流
        Stream<String> stream03 = map.keySet().stream();
            //将值转化为流
        Stream<String> stream04 = map.values().stream();
            //获取键值对
        Stream<Map.Entry<String, String>> stream05 = map.entrySet().stream();


        //将数组转化为流
        Stream<Integer> stream06 = Stream.of(1, 2, 3, 4, 5, 6);
			//int类型
        Integer[] integer = {1,2,3,4,5,6};
        Stream<Integer> stream07 = Stream.of(integer);
			//String类型
        String [] str = {"ni","aef","zsdf","dsfg"};
        Stream<String> stream08 = Stream.of(str);


    }
}

常用方法

常用的方法分为两类:

• 延迟方法：返回值仍然是Stream流接口的方法，支持链式调用
• 终结方法： 返回值类型不再是stream流接口的方法，因此不再支持类似的链式调用

forEach

返回值	方法	描述
void	forEach(Consumer<? super T> action)	对此流的每个元素执行操作。【接口方法】

Consumer 接口中包含抽象方法void accept（T t），消费一个指定泛型的数据。

​ T：流中的元素类型

Filter

返回值	方法	描述
Stream<T>	filter(Predicate<? super T> predicate)	返回由与此给定谓词匹配的此流的元素组成的流。

Predicate：函数式接口，可以使用lambda表达式对数据进行过滤。

​ 抽象方法 test(T t)

Map

返回值	方法	描述
<R> Stream<R>	map(Function<? super T,? extends R> mapper)	返回由给定函数应用于此流的元素的结果组成的流。【映射为其他类型】

Function：函数式接口，可以使用lambda表达式进行映射

​ 抽象方法：R apply (T);

Count

返回值	方法	描述
long	count()	返回此流中的元素数。

此方法是一个终结方法，统计流中元素个数，调用后不能继续使用。

Limit

返回值	方法	描述
Stream<T>	limit(long maxSize)	返回由此流的元素组成的流，截短长度不能超过 maxSize 。

截取前maxSize位的元素，组成一个新的流。

Skip

返回值	方法	描述
Stream<T>	skip(long n)	在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。

丢弃前n个元素后，追成一个新的流。

Concat

返回值	方法	描述
static <T> Stream<T>	concat(Stream<? extends T> a, Stream<? extends T> b)	创建一个懒惰连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。

练习

package com.py.Stream;

import java.util.stream.Stream;

public class DemoStreamMethor {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三", "李四", "王五", "刘六", "田七");
//        filter(stream);
//        count(stream);
//        limit(stream);
//        skip(stream.skip(3));
    }

    private static void skip(Stream<String> skip) {
        skip
                .forEach(name -> {
                    System.out.println(name);
                });
    }

    private static void limit(Stream<String> stream) {
        skip(stream.limit(3));
    }

    private static void count(Stream<String> stream) {
        System.out.println(stream.count());
    }

    private static void filter(Stream<String> stream) {
        stream.filter((String name)->{ return name.startsWith("张");})
                .forEach((name->{System.out.println(name);}));
    }
}

实例

package com.py.Stream;

import java.util.ArrayList;
import java.util.stream.Stream;

public class DemoTest {
    public static void main(String[] args) {
        ArrayList<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("迪丽热巴");
        one.add("苏星河");
        one.add("石破天");
        one.add("老子");

        Stream<String> oneStream = one.stream().filter(name -> {
            return name.length() == 3;
        }).limit(3);



        ArrayList<String > two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("赵丽颖女");
        two.add("张三丰");
        two.add("赵四");
        two.add("汪远");
        two.add("铃木爱理");

        Stream<String> twoStream = two.stream().filter(name -> {
            return name.length() == 4;
        }).skip(1);

        Stream.concat(oneStream,twoStream).map(name->{return new Person(name);}).forEach(p->{
            System.out.println(p);
        });

    }
}