java--Stream流

微扬嘴角

已于 2023-03-18 10:47:18 修改

阅读量552

点赞数

文章标签： java 算法 android

于 2023-03-12 17:30:47 首次发布

本文链接：https://blog.csdn.net/qq_51476492/article/details/129472255

版权

Stream流可以理解为工厂的流水线，一步一步地对数据进行过滤操作。Stream流在使用过程中会结合Lambda表达式，简化集合、数组操作。

一、Stream流的使用步骤：
（1）先得到一条Stream流，并把数据放上去；
（2）利用Stream流中的API进行各种操作。

二、获取Stream流的方法
在这里插入图片描述
注意（1）Collection.stream()方法的返回值类型为Stream< E >，表示的就是Stream流。

三、获取Stream流的实例
1.单列集合获取stream流
（a）使用匿名类

public class HelloWorld {


    public static void main(String[] args) {
        //单列集合获取Stream流
        ArrayList<String> list = new ArrayList<>();
        //利用Collection的addAll()方法往list中一次性添加多个数据
        Collections.addAll(list,"a","b","dada","dacaa");
        //获取到一条流水线，并把集合中的数据放到流水线上。
        Stream<String> stream1 = list.stream();
        //打印流水线上的数据（使用匿名类的形式
        stream1.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                //s:依次表示流水线上的每一个数据
                System.out.println(s);
            }
        });
    }
}

运行结果：
在这里插入图片描述
（b）使用Lambda表达式

public class HelloWorld {
    public static void main(String[] args) {
        //单列集合获取String流
        ArrayList<String> list = new ArrayList<>();
        //利用Collection的addAll()方法往list中一次性添加多个数据
        Collections.addAll(list,"a","b","dada","dacaa");
        //获取到一条流水线，并把集合中的数据放到流水线上。
        Stream<String> stream1 = list.stream();
        //打印流水线上的数据（使用Lambda表达式的形式
       list.stream().forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
2.双列集合获取Stream流
注意，双列集合不可以直接调用stream()方法，需要先转化。
（a）keySet()方法可以将双列结合中的键归到一个集合中，返回值为Set< E >，之后可以使用stream()以及其他方法。

public class HelloWorld {


    public static void main(String[] args) {
        //双列集合获取String流
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("aaa",111);
        hm.put("bbb",222);
        hm.put("ccc",333);
        hm.put("ddd",444);

        //获取Stream流,
        hm.keySet().stream().forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
（b）entrySet()可以获取键值对集合

public class HelloWorld {
    public static void main(String[] args) {
        //双列集合获取String流
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("aaa",111);
        hm.put("bbb",222);
        hm.put("ccc",333);
        hm.put("ddd",444);

        //获取Stream流,
        hm.entrySet().stream().forEach(s -> System.out.println(s));
    }
}

运行结果;
在这里插入图片描述
3.数组获取stream流：使用Arrays.stream()方法获取stream流。

public class HelloWorld {
    
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1,2,3,4,5,6,7,8,9,10};

        //获取stream流并输出
      Arrays.stream(arr).forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
4.一堆同类型的零散数据转换为stream流:Stream类静态方法of()

可以看出of()方法参数可以是多种数据类型。

public class HelloWorld {

    public static void main(String[] args) {
     Stream.of(1,2,3,4,5).forEach(s->System.out.println(s));
     Stream.of("a","b","c","d","e").forEach(s->System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
注意：Stream.of()方法如果实参是数组名，那么必须是引用数据类型的数组，如果是基本数据类型则会把整个数据当作一个元素放到stream流中。

四、Stream流的中间处理方法（过滤）
在这里插入图片描述
说明：方法的具体说明在代码注释里。
1.filter()使用匿名内部类的形式

public class HelloWorld {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","张一山","张三丰",
                "赵四","王二麻子");

        //使用filter()方法进行过滤
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                //返回值为true表示当前数据留下，其余数据过滤不要
                return s.startsWith("张");
            }
        }).forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
使用Lambda表达式：

public class HelloWorld {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","张一山","张三丰",
                "赵四","王二麻子");

        //使用filter()方法进行过滤
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
注意：Stream流使用链式编程（多个方法写成一行），如上方所示，因为保留每一步过滤的结果无意义，即使保留不同步骤的中间结果也是不能进行二次过滤的。比如说stream1通过依次过滤得到stream2,可以对stream2再使用不同的过滤方法得到stream3，但不能在对stream1使用过滤方法了。

2.limit()获取前几个元素，skip()跳过几个元素

public class HelloWorld {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","张一山","张三丰",
                "赵四","王二麻子");
        //使用limit()获取前三个元素
        list.stream().limit(3).forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
skip()：

public class HelloWorld {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","张一山","张三丰",
                "赵四","王二麻子");
        //使用skip跳过前三个元素
        list.stream().skip(3).forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
3.distinct()去重：去掉重复元素，依赖hashCode和equals()方法去重

public class HelloWorld {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","张三","张三","李四","张一山","张三丰",
                "赵四","王二麻子");
        //使用distinct()去掉重复的张三
        list.stream().distinct().skip(3).forEach(s -> System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
注意：自定义类要去掉属性值都相同的对象需要重写equals()方法。
4.concat()合并a、b两个流

public class HelloWorld {

    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三","李四","张一山");
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"张三丰", "赵四","王二麻子");
        //使用concat合并流
       Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));

    }
}

运行结果：
在这里插入图片描述
5.map转化流中的数据类型

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三-15","李四-16","张一山-17");
        //使用map()方法进行流的转换
       list1.stream().map(new Function<String, Integer>() {
           //Function<>的第一个参数表示流中的每一个数据,对应apply()方法的参数，
           // 第二个参数表示转换后的参数类型，对应apply()的返回值
           @Override
           public Integer apply(String s){
               //获取字符流中每个字符串中的年龄
             String[] arr = s.split("-");
             String ageString = arr[1];
            int age= Integer.parseInt(ageString);
            return age;
           }
       }).forEach(s->System.out.println(s));
    }
}

运行结果：
在这里插入图片描述
注意：map()方法执行完毕之后，流上的数据就变成了整数，所以在下面的forEach()当中，s依次表示流中的每一个数据，这个数据现在就是整数了。

使用Lambda表达式的形式：

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三-15","李四-16","张一山-17");
        //使用map()方法进行流的转换
       list1.stream().map(s->Integer.parseInt((s.split("-")[1]))).forEach(s->System.out.println(s));
    }
}

五、Stream流的终结方法
在这里插入图片描述
forEach()前面用过多次不再说明。
1.count()：统计流中字符串数目。

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三-15","李四-16","张一山-17");
       long count = list1.stream().count();
       System.out.println(count);
    }
}

运行结果：
在这里插入图片描述
2.toArray()：将流中数据收集到数组中

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"张三-15","李四-16","张一山-17");
       Object[] arr = list1.stream().toArray();
       System.out.println(Arrays.toString(arr));
    }
}

运行结果：
在这里插入图片描述
3.collect():收集流中的数据到单列集合list,set以及双列集合map中。
（1）收集到list集合中，参数为Collectors.toList()

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        Collections.addAll(list,"张三-15","李四-16","张一山-17");
     List<String> newList = list.stream().collect(Collectors.toList());
     System.out.println(newList);
    }
}

运行结果：
在这里插入图片描述
(2)收集到set集合中

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        Collections.addAll(list,"张三-15","李四-16","张一山-17");
     Set<String>  newSet= list.stream().collect(Collectors.toSet());
     System.out.println(newSet);
    }
}

在这里插入图片描述
注意：收集到Set集合中会自动去除重复元素。
（3）收集到一个map集合中

public class HelloWorld {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        Collections.addAll(list,"张三-15","李四-16","张一山-17");
        //Collectors.toMap()有两个参数，第一个参数表示键的生成规则,
        // 规则就是提取每一个字符串的哪个部分，用Lambda表达式->后的返回值表示
        // 注意，键值不能重复
        // 第二个参数表示值的生成规则
    Map<String,Integer> newMap =  list.stream().collect(Collectors.toMap(s->s.split("-")[0],s ->Integer.parseInt( s.split("-")[1])));
    System.out.println(newMap);
    }
}