Java进阶 之 Stream流

Stream流思想：

就相当于流水线一样，一道工序一道工序的进行排查，得出最后结果。

1.创建Stream流对象

1.1单列集合创建Stream流

//        单列 创建Stream   List 可重复的
        List list = List.of("张三","李四","王五");
        Stream stream1 = list.stream();
//        单列不可重复的
        Set set = Set.of("张三","李四","王五");
        Stream stream2 = set.stream();

1.2双列集合创建Stream流对象 

//        双列  不能直接产生Stream流对象，而是通过先转单
        Map map = Map.of("张三", 19, "李四", 30);
        Set set1 = map.keySet();
        Stream stream = set1.stream();

 注意：双列集合不能直接创建Stream流对象，要用它的 keySet()方法 获取到单列集合。

 3.数组  创建流对象

//        数组
        int[] arr = {1,2,3};
        IntStream stream3 = Arrays.stream(arr);

 数组要通过它的Arrays工具类 进行创建 Stream流。

4.相同类型;

  Stream stream4 = Stream.of("张三", "李四", "王五", "赵六");

2.Stream流常用方法

1.中间方法

概念：执行完此方法之后,Stream流依然可以继续执行其他操作

方法名	说明
Stream filter(Predicate predicate)	用于对流中的数据进行过滤
Stream limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流
Stream sorted()	返回由此流的元素组成的流，根据自然顺序排序
Stream sorted(Comparator comparator)	返回由该流的元素组成的流，根据提供的Comparator进行排序
Stream map(Function mapper)	返回由给定函数应用于此流的元素的结果组成的流
IntStream mapToInt(ToIntFunction mapper)	返回一个IntStream其中包含将给定函数应用于此流的元素的结果

 展示几个常用方法：

1.filter(s -> 关系表达式) 过滤   保留返回值为true 的

public class MyStream3 {
    public static void main(String[] args) {
//        Stream filter(Predicate predicate)：过滤
//        Predicate接口中的方法	boolean test(T t)：对给定的参数进行判断，返回一个布尔值

        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //filter方法获取流中的 每一个数据.
        //而test方法中的s,就依次表示流中的每一个数据.
        //我们只要在test方法中对s进行判断就可以了.
        //如果判断的结果为true,则当前的数据留下
        //如果判断的结果为false,则当前数据就不要.
//        list.stream().filter(
//                new Predicate() {
//                    @Override
//                    public boolean test(String s) {
//                        boolean result = s.startsWith("张");
//                        return result;
//                    }
//                }
//        ).forEach(s-> System.out.println(s));

        //因为Predicate接口中只有一个抽象方法test
        //所以我们可以使用lambda表达式来简化
//        list.stream().filter(
//                (String s)->{
//                    boolean result = s.startsWith("张");
//                        return result;
//                }
//        ).forEach(s-> System.out.println(s));、

//最后简化成

        list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));

    }
}

 2.limit(n) 保留前n个   skip(n) 跳过 前n个

public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList list = new ArrayList();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(s-> System.out.println(s));
        System.out.println("--------");

        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(s-> System.out.println(s));
        System.out.println("--------");

        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
    }
}

3.concat() 静态方法 类名直接调用 连接    

distinct() 去重方法

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList list = new ArrayList();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前4个数据组成一个流
        Stream s1 = list.stream().limit(4);

        //需求2：跳过2个数据组成一个流
        Stream s2 = list.stream().skip(2);

        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(s1,s2).forEach(s-> System.out.println(s));

        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));
    }
}

2.终结方法

常见方法

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //method1(list);
        
//        long count()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }

    private static void method1(ArrayList list) {
        //  void forEach(Consumer action)：对此流的每个元素执行操作
        //  Consumer接口中的方法void accept(T t)：对给定的参数执行此操作
        //在forEach方法的底层,会循环获取到流中的每一个数据.
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据.
        //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
        list.stream().forEach(
                new Consumer() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
      
        System.out.println("====================");
        //lambda表达式的简化格式
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        System.out.println("====================");
        //lambda表达式还是可以进一步简化的.
        list.stream().forEach(s->System.out.println(s));
    }
}

注意：调用完终结方法就会直接关闭该流，不能再调用中间方法。

；分号也有终结的作用。

 3.Stream流的收集操作******

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

常用方法：

方法名	说明
R collect(Collector collector)	把结果收集到集合中

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

方法名	说明
public static Collector toList()	把元素收集到List集合中
public static Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

 1.收集到List集合

     List list = List.of(1,2,3,4,5,6,7,8,9,10,10);
//收集成一个list集合
        Stream stream = list.stream();
        List list2 = stream.filter(s -> s % 2 == 0).collect(Collectors.toList());

        System.out.println(list2);

2.收集到Set集合

//        将数组去重 收集到 set集合中
        Stream stream2 = list.stream();
        Set set = stream2.filter(s -> s % 2 == 0).distinct().collect(Collectors.toSet());
        System.out.println(set);

3.收集到Map集合

ArrayList list = new ArrayList<>();
        list.add("张三,25");
        list.add("李四,24");
        list.add("王五,21");
        list.add("赵六,28");
//        创建Map对象
        HashMap map = new HashMap<>();

        Stream stream = list.stream();
//        用Map接收
        Map map1 = stream.filter(s -> {
//            截取字符串
            String[] strarr = s.split(",");
            String name = strarr[0];//获取到名字
            int age = Integer.parseInt(strarr[1]);
            return age >= 24;
        }).collect(Collectors.toMap(
                s -> s.split(",")[0],
                s -> s.split(",")[1]
        ));

        System.out.println(map1);