526互联

Stream流

发布时间 2023-09-09 11:49:22作者: SimpleWord
title: Stream流
index_img: https://tuchuangs.com/imgs/2023/08/09/02d7f67db46abe4c.png
tags:
  - Java SE
categories:
  - Java SE
hide: false
excerpt: Stream流、得到流、中间方法、终结方法案例

问题描述

  • 先把所有以“张”开头的元素存储到新集合中
  • 再把“张”开头的，长度为3的元素再存储到新集合中
  • 遍历最终结果

传统方式

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张无忌");
        list.add("张三丰");
        list.add("赵敏");
        list.add("张凯");
        System.out.println("list:" + list);

        ArrayList<String> list1 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张")) {
                list1.add(s);
            }
        }
        System.out.println("list1:" + list1);

        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list) {
            if (s.startsWith("张") && s.length() == 3) {
                list2.add(s);
            }
        }
        System.out.println("list2:" + list2);
    }
}

image-20230809162259810

Stream流

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("张无忌");
        list.add("张三丰");
        list.add("赵敏");
        list.add("张凯");

        list.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
    }
}

image-20230809162259810

Stream流

结合lambda和链式编程

得到Stream流

获取方式 方法名 说明
单列集合 default Stream stream() collection中的默认方法
双列集合 无 无法直接使用stream流(通过键或键值对)
数组 public static Stream stream(T[] array) Arrays工具类中的静态方法
一堆零散数据 public static Stream of(T...values) Stream接口中的静态方法

使用中间方法

Stream filter(Predicate<? super T> predicate) 过滤
Stream limit(long maxSize) 获取前几个元素
Stream skip(long n) 跳过前几个元素
Stream distinct() 元素去重，依赖(hashCode和equals方法)[重写]
static Stream concat(Stream a, Stream b) 合并a和b两个流为一个流[合并流的数据类型时它们的父类类型]
Stream map(Function<T ,R> mapper) 转换流中的数据类型

使用终结方法

名称 说明
forEach(Consumer action) 遍历流中的每个元素，并对每个元素执行指定的操作。
count() 返回流中元素的数量。
toArray() 将流中的所有元素收集到一个数组中。
collect(Collector collector) 使用提供的Collector，将流中的数据收集到一个集合中。

得到案例

单列集合

可直接使用Stream流

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); //使用工具类添加数据
        //一般会使用链式编程
        System.out.println(list.stream().filter(num -> num % 2 == 0).count());//6
    }
}

双列集合

可通过键或键值对获得

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>(); //无序
        map.put("张三", 1);
        map.put("里斯", 2);
        map.put("王五", 3);
        map.put("张开", 4);

        //方式1：通过键获得
        map.keySet().stream().filter(name -> name.startsWith("张")).forEach(s -> System.out.println(s + "-" + map.get(s)));

        System.out.println("--------------");

        //方式2：通过键值对获得
        map.entrySet().stream().filter(name -> name.getKey().startsWith("张"))
                .forEach(s -> System.out.println(s.getKey() + "-" + s.getValue()));
    }
}

image-20230809165302159

数组

  • 可通过Arrays的静态方法获得
  • 基本类型和引用类型都支持
public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4};
        String[] arr2 = {"java","Stream"};

        Arrays.stream(arr1).forEach(s -> System.out.println(s));
        System.out.println("------------");
        Arrays.stream(arr2).forEach(s-> System.out.println(s));
    }
}

image-20230809165912088

零散数据

  • Stream接口中的静态方法
  • 这些数据需要时相同类型
public class Main {
    public static void main(String[] args) {
        Stream.of(1, 2, 3, 4, 5).filter(num -> num <= 3).forEach(s -> System.out.println(s)); //of支持可变参数,也可以传递引用数据的数组[数组还是推荐使用工具类]
    }
}

image-20230809170120854

中间方法使用案例

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        //过滤
        list.stream().filter(num -> num > 5).forEach(s -> System.out.println(s));
        System.out.println("------------------");

        //限制元素
        list.stream().limit(5).forEach(s -> System.out.println(s));
        System.out.println("------------------");

        //跳过元素个数
        list.stream().skip(5).forEach(s -> System.out.println(s));
        System.out.println("------------------");

        //去重
        List<Integer> listWithDuplicates = Arrays.asList(1, 1, 2, 2, 3, 3);
        listWithDuplicates.stream().distinct().forEach(s -> System.out.println(s));
        System.out.println("------------------");

        //合并流
        Stream<Integer> stream1 = Stream.of(1, 2, 3);
        Stream<Integer> stream2 = Stream.of(4, 5, 6);
        Stream.concat(stream1, stream2).forEach(s -> System.out.println(s));
        System.out.println("------------------");

        //类型转换
        list.stream().map(num -> "" + num).forEach(s -> {
            if (s instanceof String) {
                System.out.println(s + "现在是String类型");
            }
        });
    }
}

image-20230809173348474

image-20230809173413508

终结方法

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Cherry");
        //遍历
        list.stream().forEach(s -> System.out.println(s));
        System.out.println("---------");

        //统计
        System.out.println(list.stream().count());
        System.out.println("----------");

        //存到数组
        String[] array = list.stream().toArray(s -> new String[s]);
        Arrays.stream(array).forEach(s -> System.out.println(s));
        System.out.println("----------");

        //存到集合
        List<String> collect = list.stream().collect(Collectors.toList());
        System.out.println(collect);
    }
}

image-20230809174710158