JavaSE@拓展补遗@笔记02@Stream流介绍以及Lambda表达式在其中的应用

一、Stream流

1、概述

Stream流是JDK8中的新特性，得益于Lambda表达式的应用，Stream流可以简化Java中集合和数组的操作。

2、获取流的方式

Collection单列集合

数组

import java.util.ArrayList;
import java.util.stream.Stream;
​
public class Test01 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("王一博");
        list.add("肖战");
        list.add("蔡徐坤");
        list.add("彭于晏");
​
        //通过集合获取Stream流
        Stream<String> stream1 = list.stream();
        
        //创建数组
        //如果要用Stream流不能创建基本类型数组
        Integer[] arr = {11,22,33,44};
        
        //通过数组获取Stream流
        Stream<Integer> stream2 = Stream.of(arr);
​
    }
}

3、常用方法

终结方法：

终结方法，方法的返回值不是Stream

终结方法，调用之后后面就不能再调用流的其他方法了。

count() : 获取流中元素的个数

forEach() : 遍历流中的每个元素

非终结方法：

非终结方法，方法的返回值是Stream类型

非终结方法，调用之后还可以继续调用流的其他方法。

import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.stream.Stream;
​
public class Test02 {
    public static void main(String[] args) {
        //Stream流的终结方法
​
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("王一博");
        list.add("肖战");
        list.add("蔡徐坤");
        list.add("彭于晏");
​
        //通过集合获取Stream流
        Stream<String> stream = list.stream();
        //每一个Stream流对象只能用一次
​
        //*count(): 获取流中的元素个数
        //long count = stream.count();
        //System.out.println(count);      //4
​
​
        //*forEach() :遍历流中的每个元素
        //匿名内部类
        //stream.forEach(new Consumer<String>() {
        //    @Override
        //    public void accept(String s) {
        //        //String s就是流中的每个元素
        //        System.out.println(s);
        //    }
        //});
​
        //Lambda表达式
        //stream.forEach((String s)->{System.out.println(s);});
​
        //省略写法
        stream.forEach(s->System.out.println(s));
    }
}

filter() : 过滤元素

limit(): 保留前几个元素

skip(): 跳过前几个元素

map() : 把流中的元素类型换成另一种类型

static concat() ： 把两个流合并成一个流

代码演示（Lambda表达式）：

public class Test03 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("王一博");
        list.add("肖战");
        list.add("蔡徐坤");
        list.add("彭于晏");
​
        //通过集合获取Stream流
        Stream<String> stream = list.stream();
​
        //- filter() :      过滤元素
        //如果返回的是true就表示留下元素  返回的是false表示删除元素
        //要求：留下长度为3的名字
        //Stream<String> stream2 = stream.filter(new Predicate<String>() {
        //    @Override
        //    public boolean test(String s) {
        //        return s.length() == 3;
        //    }
        //});
        //打印每个元素
        //stream2.forEach(s-> System.out.println(s));
​
        //lambda简化写法
        //stream.filter(s->s.length() == 3).forEach(s-> System.out.println(s));
​
        //- limit():      保留前几个元素
        //保留前3个元素
        //stream.limit(3).forEach(s-> System.out.println(s));
        //- skip():    跳过前几个元素
        //跳过前2个元素
        //stream.skip(2).forEach(s-> System.out.println(s));
​
        //- map() :  把流中的元素类型换成另一种类型
        //Stream<Integer> stream2 = stream.map(new Function<String, Integer>() {
        //    @Override
        //    public Integer apply(String s) {
        //        return s.length();
        //    }
        //});
        打印元素
        //stream2.forEach(s-> System.out.println(s));
​
        //简化写法
        //stream.map(s->s.length()).forEach(s-> System.out.println(s));
​
​
        Stream<String> stream2 = list.stream();
        //- static concat() ： 把两个流合并成一个流
        Stream.concat(stream, stream2).forEach(s-> System.out.println(s));
​
    }
}

4、练习（Lambda表达式）

List<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("老子");
one.add("庄子");
one.add("孙子");
one.add("洪七公");
​
List<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("张三丰");
two.add("赵丽颖");
two.add("张二狗");
two.add("张天爱");
two.add("张三");
​
//1. 第一个队伍只要名字为3个字的成员姓名；
//2. 第一个队伍筛选之后只要前3个人；
//3. 第二个队伍只要姓张的成员姓名；
//4. 第二个队伍筛选之后不要前2个人；
//5. 将两个队伍合并为一个队伍；
//6. 根据姓名创建 Person 对象；
//7. 打印整个队伍的Person对象信息。
​
​————————————————————————————————————————————————————————————————————————————————————————
代码：
        Stream<String> stream = one.stream();
        Stream<String> stream1 = two.stream();
        //1. 第一个队伍只要名字为3个字的成员姓名；
        //2. 第一个队伍筛选之后只要前3个人；
        Stream<String> stream2 = stream.filter(s -> s.length() == 3).limit(3);
        //3. 第二个队伍只要姓张的成员姓名；
        //4. 第二个队伍筛选之后不要前2个人；
        Stream<String> stream3 = stream1.filter(s -> s.startsWith("张")).skip(2);
        //5. 将两个队伍合并为一个队伍；
        Stream<String> stream4 = Stream.concat(stream2, stream3);
        //6. 根据姓名创建 Person 对象；
        //7. 打印整个队伍的Person对象信息。
        stream4.map(name->new Person(name,18)).forEach(s-> System.out.println(s));

5、收集(把流转成数组或集合)

收集成List集合

收集成Set集合

收集成数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
​
public class Test05 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        list.add("王一博");
        list.add("王一博");
        list.add("肖战");
        list.add("蔡徐坤");
        list.add("彭于晏");
​
        //通过集合获取Stream流
        Stream<String> stream = list.stream();
​
        //把流变成List集合
        //List<String> list2 = stream.collect(Collectors.toList());
        //System.out.println(list2);
​
        //把流变成Set集合
        //Set<String> set = stream.collect(Collectors.toSet());
        //System.out.println(set);
​
        //把流变成数组
        Object[] arr = stream.toArray();
        System.out.println(Arrays.toString(arr));
​
    }
}