21.5 Strem流

最新推荐文章于 2025-04-30 15:51:06 发布

southdreams

最新推荐文章于 2025-04-30 15:51:06 发布

阅读量417

点赞数 1

分类专栏： JAVASE

本文链接：https://blog.csdn.net/southdreams/article/details/103688300

版权

JAVASE 专栏收录该内容

157 篇文章

订阅专栏

生成Stream流的方式

Collection体系集合
使用默认方法stream()生成流， default Stream stream()

Map体系集合
把Map转成Set集合，间接的生成流

数组
通过Stream接口的静态方法of(T... values)生成流

演示代码：

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

/**
 *  Collection体系集合 使用默认方法stream()生成流， default Stream stream()
 *  Map体系集合 把Map转成Set集合，间接的生成流
 *  数组 通过Stream接口的静态方法of(T... values)生成流
 */
public class StreamTest_1 {
    public static void main(String[] args) {
        /**Collection体系的集合可以使用默认方法stream()生成流*/
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        /**Map体系的集合间接的生成流*/
        Map<Integer,String> map = new HashMap<>();
        Stream<Integer> keyStream = map.keySet().stream();
        Stream<String> valStream = map.values().stream();
        Stream<Map.Entry<Integer, String>> entryStream = map.entrySet().stream();

        /**数组可以通过Stream接口的静态方法of(T... values)生成流*/
        String[] strings = {"asd","sdf","asdf"};
        Stream<String> stringStream1 = Stream.of(strings);
        Stream<String> stringStream2 = Stream.of("a", "b", "c");
        Stream<Integer> integerStream = Stream.of(12, 33, 22);

    }
}

Stream流中间操作方法

中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作。

常用方法：

演示代码：

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

public class StreamTest_2 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：把list集合中以张开头的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("--------");

        //需求2：把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("--------");

        //需求3：把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

        System.out.println("Skip&Limit 的方法");
        //Stream limit(long maxSize) 返回此流中的元素组成的流，截取前指定参数个数的数据
        //取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");

        //Stream skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
        //跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");

        //跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);

        System.out.println("----concat&distinct----");
        System.out.println(list);
        //static Stream concat(Stream a, Stream b)合并a和b两个流为一个流
        Stream<String> skip = list.stream().skip(2);
        Stream<String> limit = list.stream().limit(3);
        Stream.concat(skip, limit).forEach(System.out::println);

        System.out.println("--------");
        //Stream distinct()返回由该流的不同元素（根据Object.equals(Object) ）组成的流
        //Stream.concat(skip, limit).distinct().forEach(System.out::println);
    }
}

运行结果:截取部分

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

public class StreamTest_3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");

        /**Stream sorted() 返回由此流的元素组成的流，根据自然顺序排序*/
        //按照字母顺序把数据在控制台输出
        //list.stream().sorted().forEach(System.out::println);

        /**Stream sorted(Comparator comparator)*/
        //返回由该流的元素组成的流，根据提供的Comparator进行 排序
        //按照字符串长度把数据在控制台输出
        list.stream().sorted((s1,s2) -> {
            int num = s1.length()-s2.length();
            int num2 = num==0?s1.compareTo(s2):num;
            return num2;
        }).forEach(System.out::println);
    }
}

运行结果：

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

public class StreamTest_4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //将集合中的字符串数据转换为整数之后在控制台输出
        //list.stream().map(Integer::parseInt).forEach(System.out::println);

        //int sum() 返回此流中元素的总和
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
    }
}

运行结果：

Stream流终结操作方法

终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。

常用方法：

执行完终结流后进行其他操作会报错如StreamTest_2类中

去掉注释执行最后一行代码，因为上面已经执行了forEach所有会出现下图的结果：

Stream流综合练习

演示代码：

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

public class StreamDemo {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");

        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

        /*//男演员只要名字为3个字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
        //女演员只要姓林的，并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream.concat(manStream,womanStream).forEach(System.out::println);*/

        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                womanList.stream().filter(s -> s.startsWith("林")).skip(1)).
                forEach(System.out::println);
    }
}

运行结果：

Stream流的收集操作

概念：对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中

常用方法：

工具类Collectors提供了具体的收集方式

代码演示：

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

public class StreamTest_5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");

        /*//得到名字为3个字的流
        Stream<String> listStram = list.stream().filter(s -> s.length() == 3);
        //把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> collect = listStram.collect(Collectors.toList());
        for (String s : collect) {
            System.out.println(s);
        }*/

        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);

        /*//得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(i -> i > 25);
        //把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
        }*/

        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};
        //得到字符串中年龄数据大于28的流
        Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 28);

        //把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> collect = stringStream.collect(Collectors.toMap(s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1])));

        Set<String> keySet = collect.keySet();
        for (String key : keySet) {
            Integer val = collect.get(key);
            System.out.println(key + "," + val);
        }
    }
}

运行结果：