Stream流的学习

Stream流的学习 Stream流的获取

Stream流的获取：
    单列集合：集合对象.stream()
    双列集合：不能直接获取，需要间接获取
            集合对象.KeySet().stream();
            集合对象.entrySet().stream();
    数组：
            Arrays.stream(数组名);
    同种数据类型的多个数据：
            Stream.of(2,3,4,5);

package com.shengda.Demo6Map;

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

public class Demo8MyStream2 {
    public static void main(String[] args) {
        // method1();  // 单列集合

        // method2();  // 双列集合

        // method3();  // 数组

        // 同种数据类型的多个数据
        Stream.of(2,3,4,5,6).forEach(s-> System.out.println(s));
    }

    private static void method3() {
        // 数组
        int [] arr = {2,3,4,5};
        Arrays.stream(arr).forEach(s-> System.out.println(s));  // 2 3 4 5
    }

    private static void method2() {
        // 双列集合
        HashMap hm = new HashMap<>();
        hm.put("喜羊羊",33);
        hm.put("美羊羊",35);
        hm.put("懒羊羊",44);
        hm.put("废羊羊",23);
        hm.put("暖羊羊",13);

        // 双列集合不能直接获取Stream流
        // KeySet
        // 先获取所有的键
        // 再把所有的键放到Stream流中
        // hm.keySet().stream().forEach(s -> System.out.println(hm.get(s)));

        // entrySet
        // 先获取到所有的键值对对象
        // 再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));
        
    }

    private static void method1() {
        // 单列集合
        ArrayList list = new ArrayList<>();
        list.add("aaa");
        list.add("sss");
        list.add("ccc");

        // Stream  stream = list.stream();
        // stream.forEach(s-> System.out.println(s));
        list.stream().forEach(s -> System.out.println(s));
    }
}

Stream流的filter中间 *** 作方法

    // Stream filter (Predicate predicate): 过滤
    // Predicate接口中的方法 boolean test (T t): 对给定的参数进行判断，返回一个布尔值，如果为true则留下

package com.shengda.Demo6Map;

import java.util.ArrayList;
import java.util.List;

public class Demo8MyStream3 {
    public static void main(String[] args) {
        // Stream filter (Predicate predicate): 过滤
        // Predicate接口中的方法 boolean test (T t): 对给定的参数进行判断，返回一个布尔值，如果为true则留下
        ArrayList list = new ArrayList<>(List.of("喜洋洋","美羊羊","喜气洋洋","洋洋"));

        // 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));  // 喜洋洋  喜气洋洋
    }
}

Stream流中其他常用的中间方法

    // Stream limit (long maxSize): 截取指定参数个数的数据
    // Stream skip (long n): 跳过指定参数个数的数据
    // static  Stream concat (Stream a,Stream b): 合并a和b两个流为一个流
    // Stream distinct(): 去除流中重复的元素，依赖（hashCode和equals方法）

具体代码的 *** 作如下

package com.shengda.Demo6Map;

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

public class Demo8MyStream4 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>(List.of("喜羊羊","喜羊羊","喜气洋洋","美羊羊","洋洋"));

        // Stream limit (long maxSize): 截取指定参数个数的数据

        // list.stream().limit(2).forEach(s -> System.out.println(s));  // 喜羊羊 喜气洋洋
        // Stream skip (long n): 跳过指定参数个数的数据
        // list.stream().skip(2).forEach(s -> System.out.println(s));  // 美羊羊 洋洋

        // static  Stream concat (Stream a,Stream b): 合并a和b两个流为一个流

        // ArrayList list1 = new ArrayList<>(List.of("喜羊羊","喜气洋洋","美羊羊","洋洋"));
        
        // 这个是简化后上边的代码
        // Stream.concat(list.stream(),list1.stream()).forEach(s -> System.out.println(s));
        
        // Stream distinct(): 去除流中重复的元素，依赖（hashCode和equals方法）
        list.stream().distinct().forEach(s -> System.out.println(s));
        
    }
}

Stream流的常见终结 *** 作方法

forEach(Consumer action):对此流的每个元素执行 *** 作
count():返回此流中的元素数

package com.shengda.Demo7Stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Demo8MyStream5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>(List.of("喜羊羊","喜羊羊","喜气洋洋","美羊羊","洋洋"));

        // method1(list);   // forEach()方法结束

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

    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("+++++++++++++++");
        // 简化后
        list.stream().forEach(s -> System.out.println(s));
    }
}

收集方法toList和toSet方法

package com.shengda.Demo7Stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Demo8MyStream7 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        for (int i =1; i < 11; i++) {
            list.add(i);
        }

        // filter过滤的方法
        // collect负责收集数据
                // 但是他不负责创建容器，也不负责把数据添加到容器中，
        // Collectors.toList()：在底层会创建一个List集合，并把所有的数据添加到List集合中，
        List list1 = list.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(list1);  // [2, 4, 6, 8, 10]  可以有重复的数据

        Set collect = list.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(collect);  // [2, 4, 6, 8, 10]  不能有重复的数据
    }
}

注意

在Stream流中无法直接修改集合，数组等数据源中的数据。