java Stream详解看我这一篇就够了

最新推荐文章于 2024-04-28 23:52:58 发布

X@AKS

最新推荐文章于 2024-04-28 23:52:58 发布

阅读量3.6k

点赞数 7

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_64332518/article/details/129902412

版权

Stream和IO Stream不是一类东西，Stream是Java 8 API添加的一个新的抽象，为什么使用Stream流：使用Stream流是对集合（Collection）对象功能的增强，与Lambda表达式结合，可以提高编程效率、间接性和程序可读性。

1：Stream的思想

简单而言Stream操作就相当一条流水线或者一条链子
1. 链子的头就是获得一个Stream对象
2. 链子身体就是进行流操作并且返回新的Stream对象，俗称中间方法
3. 链子的尾部就是进行流操作并且不会返回Stream对象，俗称终结方法
注意流操作不会改变原来的数据，只会改变流中数据

2：获得Stream对象

List、Map、Set、数组以及其他的一些数据都能获得Stream对象

2.1、List

List<String> ls = new ArrayList<>();
//添加多个元素
Collections.addAll(ls,new String[]{"a","b","c","d"});
System.out.println("---------单列集合获取stream-----------------");
Stream<String> stream = ls.stream();

2.2、Set

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

2.3、数组

System.out.println("---------数组第一种获取stream(不建议)-----------------");
String[] strings = new String[]{"a","b","c"};
//of()是Stream中静态方法，可以传递数组类型的参数，也可以是一个数组前提是引用类型，如果是int类型的数组就会被把曾哥数组进行装箱而不是数组中的每个数据进行装箱
Stream<String> stream1 = Stream.of(strings);
System.out.println("---------数组第二种获取stream-----------------");
Stream<String> stream2 = Arrays.stream(strings);

2.4、零散的数据

Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 4); //这里的参数为数组

3：Stream常用的方法

中间方法：返回新的Stream，建议链式编程。注意：用过Stream对象再用就会报错

名称	说明
filter	过滤
limit	获取前几个元素(下标不以0开始)
skip	跳过前几个元素(下标不以0开始)
distinct	元素去重(依赖hashcode方法和equals方法，自定义的类型需要重写)
concat	Stream中的静态方法，合并两个流
of	Stream中的静态方法，返回一个流
map	转换流中的数据的数据类型

public static   void filter(){
    ArrayList<String> ls = new ArrayList<>();
    Collections.addAll(ls,"张无忌","周芷若","赵坤","张强","张翠山","张良","王二码字","谢广坤");
    System.out.println("-------------流的filter过滤方法-------------");
    ls.stream().filter(new Predicate() {
        @Override
        public boolean test(Object o) {
            //返回true 表示当前数据保存
            //返回false 表示当前数据不保存
            return false;
        }
    });
    //过滤集合中姓张的
    ls.stream().filter(s -> {
        boolean isHave = s.startsWith("张");
        return isHave;
    }).forEach(System.out::println);
    //过滤集合中姓张的
    ls.stream().filter(s -> s.startsWith("张")
    ).forEach(System.out::println);
}

public static void skipAndLimit() {
    ArrayList<String> ls = new ArrayList<>();
    Collections.addAll(ls,"张无忌","周芷若","赵坤","张强","张翠山","张良","王二码字","谢广坤");
    System.out.println("-------------流的skip方法-------------");
    //跳过前3个元素,这个不是从0开始下标，就是正常的数数
    ls.stream().skip(3).forEach(System.out::println);
    System.out.println("-------------流的limit方法-------------");
    //获取前三个元素,这个不是从0开始下标，就是正常的数数
    ls.stream().limit(3).forEach(System.out::println);
    System.out.println("-------------流的limit方法和skip方法联合使用-------------");
    //获取第三个到第六个的元素
    ls.stream().skip(3).limit(3).forEach(System.out::println);
}

public static void distinct() {
    ArrayList<String> ls = new ArrayList<>();
    Collections.addAll(ls,"张无忌","周芷若","赵坤","张强","张翠山","张良","王二码字","谢广坤","张无忌","张无忌");
    System.out.println("-------------流的distinct去重方法-------------");
    ls.stream().distinct().forEach(System.out::println);
}

public static void concat() {
    ArrayList<String> ls1 = new ArrayList<>();
    Collections.addAll(ls1,"张无忌","周芷若","赵坤","张强","张翠山","张良","王二码字","谢广坤","张无忌","张无忌");
    ArrayList<Integer> ls2 = new ArrayList<>();
    Collections.addAll(ls2,1,2,3,4,5);
    System.out.println("-------------流的concat合并方法-------------");
    //cancat方法是Stream的静态方法，使用注意点：须保持两个流的类型尽量一致，因为好操作
    Stream.concat(ls1.stream(),ls2.stream()).forEach(System.out::println);
}

public static void map() {
    ArrayList<String> ls1 = new ArrayList<>();
    Collections.addAll(ls1,"张无忌-123","周芷若-12","赵坤-45","张强-56");
    System.out.println("-------------流的map转换类型方法-------------");
    //要求需要将ls1的String类型转换成Integer类型，其实也就是另一种加强的过滤器
    ls1.stream().map(new Function<String, Object>() {
        //s是流中的每个数据
        @Override
        public Object apply(String s) {
            String[] split = s.split("-");
            String s1 = split[1];
            //返回结果值，类型就是结果的类型
            return Integer.parseInt(s1);
        }
    });

    ls1.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(System.out::println);

}

终结方法：不会返回新的Stream流

名称	说明
forEach	遍历，没有返回值
count	统计流中的元素个数类似List的size()方法，返回long类型
toArray	收集流中的数据，放到数组中
collect	收集流中的数据，放到LIst/Set/Map

public static void count() {
    ArrayList<Object> objects = new ArrayList<>();
    Collections.addAll(objects, "a", "b", "c");
    System.out.println("------------Stream的count统计方法");
    // 等于集合的size()方法
    System.out.println(objects.stream().count());

}

public static void toArray() {
    ArrayList<String> ls = new ArrayList<>();
    Collections.addAll(ls, "a", "b", "c");
    System.out.println("------------Stream的toArray方法:把流中的数据存到数组中");
    //toArray()无参表示存放到Object数组中
    Arrays.stream(ls.stream().toArray()).forEach(System.out::println);
    //toArray()有参重写接口中的方法指明返回类型的数组
    //IntFunction的泛型必须是数组类型的
    ls.stream().toArray(new IntFunction<String[]>() {
        //形参：表示流中的数组个数，返回的数组的长度就是这个形参
        @Override
        public String[] apply(int value) {
            return new String[value];
        }
    });
    String[] strings = ls.stream().toArray(v -> new String[v]);
    System.out.println(strings.length);
}

public static void collect() {
    ArrayList<String> ls = new ArrayList<>();
    Collections.addAll(ls, "a", "b", "c");
    System.out.println("------------Stream的collect方法:把流中的数据存到List(List,Map,Set)中");
    ls.stream().collect(Collectors.toList()).forEach(System.out::println);
    ;
    System.out.println("------------Stream的collect方法:把流中的数据存到Set(List,Map,Set)中");
    //可以去重
    ls.stream().collect(Collectors.toSet()).forEach(System.out::println);
    System.out.println("------------Stream的collect方法:把流中的数据存到Map(List,Map,Set)中");
    /*
    Collections 和 Collectors 不一样
    Collectors.toMap(键生成的规则,value生成的规则)
    键生成的规则:
        Function<T,E> ：
                    T是流中每一个数据类型
                    E是我们想要这个键到map中是什么类型
        方法apply(T t) :
                    t:是我们每个流中的数据，这里就是键生成规则的地方

    value生成的规则:
        Function<T,E> ：
                    T是流中每一个数据类型
                    E是我们想要这个值到map中是什么类型
       方法apply(T t) :
                   t:是我们每个流中的数据，这里就是值生成规则的地方
    */
   /* ls.stream().collect(Collectors.toMap(new Function<String, String>() {
        @Override
        public String apply(String s) {
            return null;
        }
    }, new Function<String, Integer>() {
        @Override
        public Integer apply(String s) {
            return null;
        }
    }));*/
    ArrayList<String> ls1 = new ArrayList<>();
    Collections.addAll(ls1, "张无忌-男-41", "周芷若-女-12", "张三-男-30", "李四-男-23");
    //要求：把所有男性，存到map中,key是名字，value是年龄。注意点不要让键重复
    ls1.stream()
            .filter(data -> "男".equals(data.split("-")[1]))
            .collect(Collectors.toMap(s1 -> s1.split("-")[0], s2 -> Integer.parseInt(s2.split("-")[2])))
            .entrySet().stream().forEach(t -> System.out.println("key="+t.getKey()+",value="+t.getValue()));
}

public static void toList() {
    ArrayList<String> ls = new ArrayList<>();
    Collections.addAll(ls, "a", "b", "c");
    System.out.println("------------Stream的toList方法:把流中的数据存到List(只能是List)中");
    ls.stream().toList().forEach(System.out::println);
}

4：练习

如果认真看了以上，就做做下面的练习，稳固自己所看的

/**
 * 练习一：定义一个集合并添加一些整数：1，2，3，4，5，6，7，8，9，10，过滤奇数，留下偶数，并将结果保存到数组中然后并打印
 * @author xxl
 * @date 2023/4/1
 */
public class Exercise1 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        //给集合添加元素
        Collections.addAll(integers,1,2,3,4,5,6,7,8,9,10);
        Arrays.stream(integers.stream().filter(date -> date%2 == 0)
                .toArray(length -> new Integer[length]))
                .forEach(System.out::println);
    }
}

/**
 * 练习二：创建一个List集合，并添加字符串(字符串中前面是名字，后面是年龄，中间用逗号隔开)如：“xxl,12”
 * 保留年龄大等于24岁的人，并收集到Map集合中，名字为key，年龄为值然后打印
 *
 * @author xxl
 * @date 2023/4/1
 */
public class Exercise2 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        //给集合添加元素
        Collections.addAll(strings,"陈一，12","熊二，24","张三，40","李四，23","王五，34","许六，10");
        //注意Collections和Collectors是不一样的
        strings
                .stream()
                .filter(date -> Integer.parseInt(date.split("，")[1]) >= 24)
                //为什么我会在toMap(key,value)value用Integer解析因为我想这个Map的泛型为Map<String,Integer>否则就是Map<String,String>
                .collect(Collectors.toMap(key -> key.split("，")[0],value -> Integer.parseInt(value.split("，")[1])))
                //在这个Map的基础上获得这个Map的Stream对象然后打印
                .entrySet().stream().forEach(System.out::println);
    }
}

/**
 * 练习三：现在有两个map1，map2
 * map1:中存有男演员的年龄和名字
 * map2:中存有女演员的年龄和名字
 * 要求：男演员只要名字长度为3的，女演员只要年龄大于18的。然后将两者合二为一收集在一个List集合中格式为"名字,年龄"
 * 再然后就是将这个集合中的数据封装在Actor类中属性只有name:String,age:Integer,再将所有的演员对象保存到List集合中并打印
 * @author xxl
 * @date 2023/4/1
 */
public class Exercise3 {
    public static void main(String[] args) {
        HashMap<String, Integer> actors  = new HashMap<>();
        actors.put("张三",20);
        actors.put("黄晓明",35);
        actors.put("陈伟霆",43);
        actors.put("乔振宇",34);
        HashMap<String, Integer> actresses = new HashMap<>();
        actresses.put("迪丽热巴",20);
        actresses.put("刘亦菲", 10);
        actresses.put("刘诗诗", 24);
        ArrayList<Actor> ls = new ArrayList<>();
        Stream.concat(
                actors.entrySet().stream().filter(entry -> entry.getKey().length() == 3),
                actresses.entrySet().stream().filter(entry -> entry.getValue() > 18)
        ).toList().forEach(date ->{
            Actor actor = new Actor(date.getKey(), date.getValue());
            ls.add(actor);
        });
        //打印
        ls.stream().forEach(System.out::println);
    }
}
class Actor{
    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    private String name;
    private Integer age;

    public Actor(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}