Java基础学习笔记28——Stream流

目录

1、体验Stream流

2、Stream流的生成方式

3、Stream流的常见中间操作方法

4、Stream流的常见终结操作方法

5、Stream流的收集操作

---

1、体验Stream流

需求：按照下面的要求完成集合的创建和遍历：

1. 创建一个集合，存储多个字符串元素；
2. 把集合中所有以“张”开头的元素存储到一个新的集合；
3. 把“张”开头的集合中的长度为3的元素存储的一个新的集合；
4. 遍历上一步得到的集合。

使用Stream流的方式完成过滤操作：

• list.stream().filter(s.startWith("张").filter(s->s.length()==3).forEach(System.out::println));
• 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生成流、过滤姓张、过滤长度为3、逐一打印。

2、Stream流的生成方式

Stream流的使用：

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

Stream流的常见生成方式：

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

代码演示：

package StreamPackage;

import java.util.*;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流：default Stream<E> stream();
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();
        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();

        //Map体系的集合间接地生成流：
        Map<String, Integer> map = new HashMap<String, Integer>();
        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)生成流：
        String[] strArray = {"Hello", "World", "Java"};
        Stream<String> strArrayString = Stream.of(strArray);
//        Stream.of("Hello", "World", "Java");
//        Stream.of(10, 20, 30);

    }
}

3、Stream流的常见中间操作方法

• Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤。Predicate接口中的方法：boolean test(T t)：对给定的参数进行判断，返回一个布尔值。
• Stream<T> limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据。
• Stream<T> skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流。
• Stream<T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流。
• Stream<T> distinct()：返回由该流的不同元素（根据Object.equals(Object)）组成的流。
• Stream<T> sorted()：返回由此流的元素组成的流，根据自然顺序排序。
• Stream<T> sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparatpr进行排序。
• <R> Stream<R> map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流。Function接口中的方法：R apply(T t)；
• IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream，其中包含将给定函数应用于此流的元素的结果。IntStream：表示原始int流；ToIntFunction接口中的方法:int applyAsInt(T value)；

4、Stream流的常见终结操作方法

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

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

5、Stream流的收集操作

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

• Stream流的收集方法：R collect(Collector collector)。
• 但是这个收集方法的参数是一个Collector接口。

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

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

代码演示：

package StreamPackage;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        list.add("张三三");
        list.add("李四");
        list.add("王五五");
        list.add("赵六");
        //得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
        //把使用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<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);
        //得到大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age > 25);
        //把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
        }

        System.out.println("-------------");
        //定义一个字符串数组，每一个字符串数组由姓名数据和年龄数据组合而成
        String[] strArray = {"张三，18", "李四，22", "王五，26", "赵六，20"};
        //得到字符串中年龄数据大于19的流
        Stream<String> arrayStream = Stream.of(strArray).
                filter(s -> Integer.parseInt(s.split("，")[1]) > 19);
        //把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键，年龄作值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(
                s -> 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);
        }
    }
}


结果：
张三三
王五五
-------------
50
40
30
-------------
李四，22
王五，26
赵六，20