Stream流

Stream流的使用：

• 生成流
  • 通过数据源（集合,数组等）生成流
  • 例如：list.stream()
• 中间操作
  • 一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
  • 例如：filter()
• 终结操作
  • 一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
  • 例如：forEach()

Stream流的生成方式

Stream流的常见生成方式

• Collection体系的集合可以使用默认方式stream()生成流
  • default Stream stream()
• Map体系的集合间接的生成流
• 数组可以通过Stream接口的静态方法 of(T... values)生成流

public class StreamDemo{
    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<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream(); // 键对应的流
        Stream<Integer> valueStream = map.values().stream(); // 值对应的流
        Stream<Map.Entry<String,Integer>> entryStream = map.entrySet().stream(); // 键值对对象对应的流
        
        // 数组可以通过Stream接口的静态方法 of(T... values)生成流
        Stream<String> strArrayStream = Stream.of("hello","world","java");
        Stream<Integer> intArrayStream = Streamof(10,20,30);
    }
}

Stream流的常见中间操作方法

• Stream filter(Predicate predicate)：用于对流中的数据进行过滤操作
  • 依赖于Predicate接口中的方法boolean test(T t)：对给定的参数进行判断，返回一个布尔值
• 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)：返回由给定函数应用于此流的元素的结果组成的流
  • 依赖于Function接口中的方法R apply(T t)
• IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream，其中包含将给定函数应用于此流的元素的结果

/* Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤操作
- 依赖于Predicate接口中的方法boolean test(T t)：对给定的参数进行判断，返回一个布尔值*/

public class StreamDemo01{
    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.stream().filter((String s) -> {
            return s.startsWith("小");
        }).forEach(System.out::println);*/
        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("--------");
        
        // 整合第1步和第2步，在控制台输出，以小开头，长度为3的元素
        list.stream().filter(s ->  s.startsWith("小")).filter(s ->  s.length()==3).forEach(System.out::println);
    }
}

// 控制台输出结果
小明
小茹
小鹅鹅
--------
大兰兰
小鹅鹅
--------
小鹅鹅

/* - Stream<T> limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
- Stream<T> skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流*/

public class StreamDemo02{
    public static void main(String[] args){
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小明");
        list.add("大兰兰");
        list.add("小茹");
        list.add("大强");
        list.add("小鹅鹅");
        list.add("大吴");
        
        // 1.取前3个数据输出在控制台
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");
        
        // 2.跳过3个元素，把剩下的元素输出在控制台
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");
        
        // 3.跳过2个元素，把剩下的元素中前2个输出在控制台
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

// 控制台输出结果
小明
大兰兰
小茹
--------
大强
小鹅鹅
大吴
--------
小茹
大强

/* - static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
- Stream<T> distinct()：返回由该流的不同元素（根据Object.equals(Object)）组成的流*/

public class StreamDemo03{
    public static void main(String[] args){
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("小明");
        list.add("大兰兰");
        list.add("小茹");
        list.add("大强");
        list.add("小鹅鹅");
        list.add("大吴");
        
        // 1.取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);
        
        // 2.跳过2个元素，把剩下的元素组成一个流
        Stream<String> s2 = list.stream().skip(2);
        
        // 3.合并1和2得到的流，并把结果输出在控制台
        Stream.concat(s1,s2).forEach(System.out::println);
        System.out.println("--------");
        
        // 4.合并1和2得到的流，并把结果输出在控制台,要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

// 控制台输出结果
小明
大兰兰
小茹
大强
小茹
大强
小鹅鹅
大吴
--------
小明
大兰兰
小茹
大强
小鹅鹅
大吴

/* - Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序
- Stream<T> sorted(Comparator comparator)：返回由此流的元素组成的流，根据提供的Comparator进行排序*/

public class StreamDemo04{
    public static void main(String[] args){
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("xiaoming");
        list.add("dalanlan");
        list.add("xiaoru");
        list.add("daqiang");
        list.add("xiaoee");
        list.add("dawu");
        
        // 1.按照字母顺序把数据输出在控制台
        list.stream().sorted().forEach(System.out::println);
        System.out.println("--------");
        
        // 2.按照字符串长度把数据输出在控制台--当长度相同时按照字母自然顺序排序
        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);
    }
}

// 控制台输出结果
dalanlan
daqiang
dawu
xiaoee
xiaoming
xiaoru
--------
dawu
xiaoee
xiaoru
daqiang
dalanlan
xiaoming

/* - <R> Stream<R> map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流
  - 依赖于Function接口中的方法R apply(T t)
- IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream，其中包含将给定函数应用于此流的元素的结果*/

public class StreamDemo05{
    public static void main(String[] args){
        // 创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
        
        // 1.将集合中的字符串数据转换为整数之后输出在控制台
        // 方式一：
        /*list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        System.out.println("--------");*/
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("--------");
        // 方式二：
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("--------");
        
        // 2.将集合中的字符串数据转换为整数之后将所有元素总和输出在控制台
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

// 控制台输出结果
10
20
30
40
50
--------
10
20
30
40
50
--------
150

Stream流的常见终结操作方法

Stream流的常见终结操作方法：

• void forEach(Consumer action)：对此流的每一个元素执行操作
  • 依赖于Consumer接口中的方法void accept(T t)：对给定的参数执行操作
• long count()：返回此流中的元素个数

public class StreamDemo{
    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.stream().forEach(System.out::println);
        System.out.println("--------");
        
        // 2.统计集合中有几个元素以小开头，并把统计结果输出在控制台
        long count = list.stream().filter(s ->  s.startsWith("小")).count();
        System.out.println(count);
    }
}

// 控制台输出结果
小明
大兰兰
小茹
大强
小鹅鹅
大吴
--------
3

Stream流的收集操作

对数据使用Stream流的方式操作完毕后，如果想把流中的数据收集到集合中，该怎么办呢？

Stream流的收集方法

• R collect(Collector collector)
• 不过这个收集方法的参数是一个Collector接口

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

• public static Collector toList()：把元素收集到List集合中
• public static Collector toSet()：把元素收集到Set集合中
• public static Collector toMap(Function keyMapper, Function valueMapper)：把元素收集到Map集合中

public class CollectorDemo{
    public static void main(String[] args){
        // 创建一个List集合，存储多个字符串元素
        List<String> list = new ArrayList<>();
        list.add("小明");
        list.add("大兰兰");
        list.add("小茹");
        list.add("大强强");
        // 1.得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s ->  s.length()==3);
        // 2.把使用Stream流操作完毕的数据收集到List集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for(String name : names){
            System.out.println(name);
        }
        System.out.println("--------");
        
        // 创建一个Set集合，存储多个整数元素
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);
        // 3.得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age>25);
        // 4.把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStreamset.collect(Collectors.toSet());
        for(Integer age : ages){
            System.out.println(age);
        }
        System.out.println("--------");
        
        // 创建一个字符串数组，每一个字符串数据由姓名和年龄组合而成
        String[] strArray = {"小明,30","大兰兰,35","小茹,33","大强强,25"}
        // 5.得到字符串中年龄大于28的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1])>28);                    
         // 6.把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中姓名为键，年龄为值
        Map<String,Integer> map = arrayStream.collect(Collectors.toMap(s -> split(",")[0],s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            Integer value = map.get(key);
            System.out.println(key+","+value);
        }
    }
}

// 控制台输出结果
大兰兰
大强强
--------
30
33
35
--------
小明,30
小茹,33
大兰兰,35