Java中Stream流的使用示例详解_Java

在 java 中，stream 流是 java 8 引入的一个强大特性，它允许你以声明式的方式处理集合数据。stream 流提供了一种高效且易于使用的方式来对数据进行过滤、映射、排序、聚合等操作，使代码更加简洁和可读。

1. 获取stream流

要使用stream流首先要获取到stream流

public static void main(string[] args) {
        //创建stream流
        //1. 单列集合创建
        list<string> list = new arraylist<>();
        stream<?> stream1 = list.stream();
        set<string> set = new hashset<>();
        stream<?> stream2 = set.stream();
        stack<string> stack = new stack<>();
        stream<?> stream3 = stack.stream();
        queue<string> queue = new linkedlist<>();
        stream<?> stream4 = stack.stream();
        //2. 双列集合创建
        map<string, string> map = new hashmap<>();
        stream<?> stream5 = map.entryset().stream();
        //3. 数组创建
        int[] arr = {1, 2 ,3};
        intstream stream6 = arrays.stream(arr);
        //4. 零散数据创建
        stream<?> stream7 = stream.of(1, 2, 3, 4);
    }

注意 stream.of(t... values) values为变长参数可以接收一个数组，但是这里只能接收引用类型的数组，如果是基础类型的数据由于不会自动装包会把整个数组视为一个数据

2. 中间方法

当我们获取到stream流后就可以调用其中的一些方法来对其中的数据进行一些操作，其中的方法分为两大类，其一就是中间方法，中间方法的特点是会返回一个新的 stream 流，允许你链式调用多个操作：

stream<t> filter(predicate<t>)：过滤满足条件的元素。
stream<t> limit(long)：限制元素数量。
stream<t> skip(long)：跳过前 n 个元素。
stream<t> distinct()：去重。
static<t> stream<t> concat(stream，stream )：合并a和两个流作为一个流
stream<t> sorted()：排序。
stream<t> map(function<t, r>)：将元素转换为另一种类型。

注意：

每个stream流只能使用一次，中间方法返回的是一个新的stream流
修改stream流中的数据不会影响原来集合或数组中的数据

2.1 filter使用示例

filter方法接收一个predicate类型的参数，我们转到其定义：

可以看到这是一个函数式接口，同时test方法的描述也说明了，如果参数匹配则返回true否则返回false，这里的含义即为，如果该数据（t）是符合要求的则通过，否则不通过：

    public static void filtertest() {
        list<string> list = new arraylist<>();
        collections.addall(list, "张明", "张三丰", "张良", "张明朱诺", "杨过", "小龙女");
        //这里筛选以张开头且长度为3的字符串
        list.stream()
                .filter(s -> s.startswith("张"))
                .filter(s -> s.length() == 3)
                .foreach(x-> system.out.print(x + " "));
    }

这里我们使用lambad表达式重写test方法，先赛选了以张开头的数据，再赛选了长度为3的数据最后使用foreach输出

2.2 limit 和skip使用

limit接收一个long类型的参数表示只保留前n个元素，skip同样接收一个long类型的参数表示要跳过前n个元素：

    public static void limitandskiptest() {
        list<string> list = new arraylist<>();
        collections.addall(list, "张明", "张三丰", "张良", "张明朱诺", "杨过", "小龙女");
        system.out.println("limit:");
        list.stream()
                .limit(4)
                .foreach(x-> system.out.print(x + " "));
        system.out.println("\nskip:");
        list.stream()
                .skip(3)
                .foreach(x-> system.out.print(x + " "));
        system.out.println("\nlimit-skip:");
        list.stream()
                .limit(4)
                .skip(3)
                .foreach(x-> system.out.print(x + " "));
        system.out.println("\nskip-limit:");
        list.stream()
                .skip(3)
                .limit(4)
                .foreach(x-> system.out.print(x + " "));
    }

运行结果：

2.3 distinct 和concat

    public static void distinctandconcattest() {
        list<string> list1 = new arraylist<>();
        collections.addall(list1, "张三丰", "张三丰", "杨过", "张明朱诺", "杨过", "小龙女");
        list<string> list2 = new arraylist<>();
        collections.addall(list2, "张明", "张三丰", "迪迦");
        system.out.println("\ndistinct:");
        list1.stream()
                .distinct()
                .foreach(x-> system.out.print(x + " "));
        system.out.println("\nconcat:");
        stream.concat(list1.stream(), list2.stream())
                .foreach(x-> system.out.print(x + " "));
    }

运行结果：

2.4 stored使用

    public static void sortedtest() {
        list<string> list1 = new arraylist<>();
        collections.addall(list1, "张明", "张三丰", "迪迦");
        list<integer> list2 = new arraylist<>();
        collections.addall(list2, 1, 2, 3);
        system.out.println("\nsortedlist1:");
        list1.stream()
                .sorted()
                .foreach(x-> system.out.print(x + " "));
        system.out.println("\nsortedlist2:");
        list2.stream()
                .sorted()
                .foreach(x-> system.out.print(x + " "));
        system.out.println("\nsortedlist2desc:");
        list2.stream()
                .sorted(((o1, o2) -> o2 - o1))
                .foreach(x-> system.out.print(x + " "));
    }

sorted不传参数时默认是排降序，可以传入比较器自定义排序规则

2.5 map使用

    public static void maptest() {
        list<string> list1 = new arraylist<>();
        collections.addall(list1, "张明-16", "张三丰-23", "迪迦-3000");
        //获取每个人的年龄
        /**
         * 第一个参数对应原本的数据类型，第二个参数代表要转成的数据类型
         */
        list1.stream().map(new function<string, integer>() {
            @override
            public integer apply(string s) {
                return integer.parseint(s.split("-")[1]);
            }
        }).foreach(x-> system.out.print(x + " "));
        system.out.println();
        //使用lambada表达式
        list1.stream()
                .map(s -> integer.parseint(s.split("-")[1]))
                .foreach(x-> system.out.print(x + " "));
    }

运行结果：

3. 终结方法

可以理解为结束方法，不会再返回stream流

常用的终结方法有：

foreach(consumer<t>)：遍历每个元素。
count()：计算元素数量。
toarray()：将元素转换为数组。
collect(collector<t, a, r>)：将元素收集到集合中。

3.1 foreach/count/toarray()使用

    public static void countandtoarraytest() {
        list<string> list1 = new arraylist<>();
        collections.addall(list1, "张三丰", "张三丰", "杨过", "张明朱诺", "杨过", "小龙女");
        list<integer> list2 = new arraylist<>();
        collections.addall(list2, 1, 2, 3);
        system.out.println(list1.stream().count());
        system.out.println(list2.stream().count());
        //<>为需要创建的数组的类型
        string[] str = list1.stream().toarray(new intfunction<string[]>() {
            @override
            public string[] apply(int value) {
                //value代表数据的数量，我们返回一个长度大于等于value的数据即可
                return new string[value];
            }
        });
        system.out.println(arrays.tostring(str));
        //使用lambada表达式
        integer[] arr = list2.stream().toarray(value -> new integer[value]);
        system.out.println(arrays.tostring(arr));
    }

3.2 collect 使用

将流中的元素收集到集合中

    public static void collecttest() {
        list<string> list1 = new arraylist<>();
        collections.addall(list1, "张三丰-男-23", "杨过-男-32", "张三丰-男-23", "张明朱诺-女-19", "小龙女-女-18");
        //收集所有男性
        //list
        list<string> list = list1.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(collectors.tolist());
        system.out.println(list);
        //set
        set<string> set = list1.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .collect(collectors.toset());
        system.out.println(set);
        //map
        //收集男性，名字作为键，年龄作为值
        map<string, integer> map1 = list1.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .distinct()//map中key不能重复，所以先去重
                .collect(collectors.tomap(
                        new function<string, string>() {
                            @override
                            public string apply(string s) {
                                return s.split("-")[0];
                            }
                        },
                        new function<string, integer>() {
                            @override
                            public integer apply(string s) {
                                return integer.parseint(s.split("-")[2]);
                            }
                        }
                ));
        system.out.println(map1);
        //使用lambada表达式
        map<string, integer> map2 = list1.stream()
                .filter(s -> "男".equals(s.split("-")[1]))
                .distinct()//map中key不能重复，所以先去重
                .collect(collectors.tomap(
                        s -> s.split("-")[0],
                        s -> integer.parseint(s.split("-")[2])
                ));
        system.out.println(map2);
    }

这里特别说明tomap()方法，