Stream 流

1. 体验 Stream 流

需求：

• 创建一个集合，存储多个字符串元素
• 把集合中所有以"张"开头的元素存储到一个新的集合
• 把"张"开头的集合中的长度为 3 的元素存储到一个新的集合
• 遍历上一步得到的集合

实现：

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<String>();
        for (String s : list) {
            if (s.startsWith("张")) {
                zhangList.add(s);
            }
        }

        //把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList = new ArrayList<String>();
        for (String s : zhangList) {
            if (s.length() == 3) {
                threeList.add(s);
            }
        }

        //遍历上一步得到的集合
        for (String s : threeList) {
            System.out.println(s);
        }
        System.out.println("--------");

        //Stream流来改进
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

运行结果：

张曼玉
张无忌
--------
张曼玉
张无忌

使用 Stream 流的方式的优点：

• 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为 3、逐一打印
• Stream 流把真正的函数式编程风格引入到 Java 中

2. Stream 流的思想

Stream 流的思想概述：

Stream 流的使用：

• 生成流

  通过数据源(集合，数组等)生成流

  list.stream()
  

• 中间操作

  一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用

  filter()
  

• 终结操作

  一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作

  forEach
  

3. Stream 流的生成方式

Stream 流的常见生成方式：

• Collection 体系的集合可以使用默认方法 stream() 生成流

  default Stream<E> stream()
  

• Map 体系的集合间接的生成流

• 数组可以通过 Stream 接口的静态方法 of(T… values) 生成流

代码：

public class StreamDemo {
    public static void main(String[] args) {
        //Collection 体系的集合可以使用默认方法 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> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }

}

4. Stream 流的常见中间操作方法

概念：中间操作的意思是，执行完此方法之后，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)	返回由给定函数应用于此流的元素的结果组成的流
	Function 接口中的方法 R apply(T t)
IntStream mapToInt(ToIntFunction mapper)	返回一个 IntStream 其中包含将给定函数应用于此流的元素的结果
	ToIntFunction 接口中的方法 int applyAsInt(T value)

filter 代码演示

public class StreamDemo01 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：把list集合中以张开头的元素在控制台输出
        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("--------");
        
        //需求3：把list集合中以张开头的，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

运行结果：

张曼玉
张敏
张无忌
--------
林青霞
张曼玉
王祖贤
张无忌
--------
张曼玉
张无忌

limit 和 skip 代码演示

public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        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);
    }
}

运行结果：

林青霞
张曼玉
王祖贤
--------
柳岩
张敏
张无忌
--------
王祖贤
柳岩

concat 和 distinct 代码演示

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

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

运行结果：

林青霞
张曼玉
王祖贤
柳岩
张敏
张无忌

sorted 代码演示

public class StreamDemo04 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("linqingxia");
        list.add("zhangmanyu");
        list.add("wangzuxian");
        list.add("liuyan");
        list.add("zhangmin");
        list.add("zhangwuji");

        //需求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);
    }
}

运行结果：

linqingxia
liuyan
wangzuxian
zhangmanyu
zhangmin
zhangwuji
--------
liuyan
zhangmin
zhangwuji
linqingxia
wangzuxian
zhangmanyu

map 和 mapToInt 代码演示

public class StreamDemo05 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //需求：将集合中的字符串数据转换为整数之后在控制台输出
         list.stream().map(Integer::parseInt).forEach(System.out::println);
//         list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
        System.out.println("--------");

        // int sum() 返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

运行结果：

10
20
30
40
50
--------
150

5. Stream 流终结操作方法

概念：终结操作的意思是，执行完此方法之后，Stream 流将不能再执行其他操作。

常用方法：

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

代码：

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
        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

6. Stream 流综合练习

需求：

• 演员类 Actor，里面有一个成员变量 name，一个带参构造方法，以及成员变量对应的 get/set 方法

• 现在有两个 ArrayList 集合，分别存储 6 名男演员名称和 6 名女演员名称，要求完成如下的操作 ：

  • 男演员只要名字为 3 个字的前三人
  • 女演员只要姓林的，并且不要第一个
  • 把过滤后的男演员姓名和女演员姓名合并到一起
  • 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据

代码：

public class Actor {
    private String name;

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class StreamDemo {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<String>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");
        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

        // 男演员只要名字为 3 个字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
        // 女演员只要姓林的，并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        // 把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);

        // 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
        stream.map(Actor::new).forEach(s -> System.out.println(s.getName()));
    }
}

运行结果：

周润发
刘德华
周星驰
林青霞
林志玲

7. 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集合中

代码：

public class CollectDemo {
    public static void main(String[] args) {
        //创建 List 集合对象
        List<String> list = new ArrayList<String>();
        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<Integer>();
        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 = setStream.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 -> 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);
        }
    }
}

运行结果：

林青霞
张曼玉
王祖贤
--------
33
35
30
--------
林青霞 30
王祖贤 33
张曼玉 35