Java8之后的Stream流操作

什么是 Stream 流？

简单来说，我们可以使用 java.util.Stream 对一个包含一个或多个元素的集合做各种操作。这些操作可能是 中间操作 亦或是 终端操作。 终端操作会返回一个结果，而中间操作会返回一个 Stream 流。

需要注意的是，你只能对实现了 java.util.Collection 接口的类做流的操作。

---

stream 是支持顺序(stream())和并行(parallelStream())的。顺序流操作是单线程操作，而并行流是通过多线程来处理的，能够充分利用物理机 多核 CPU 的优势，同时处理速度更快。

推荐在数据量大且硬件配置够的时候使用并行流，在普通情况下使用顺序流就可以了

---

本次介绍一下stream的几个功能实现点

• Filter过滤
• Sorted排序
• Map转换
• Collect组装集合操作
• Match匹配
• Count计数

首先先定义本次的测试数据结构

package streamTest;

/**
 * @author huizhou
 * @date 21/11/11
 * @Description TODO
 */
public class DataTest {
    private Integer id;
    private String name;
    private String addr;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public DataTest() {
    }

    public DataTest(Integer id, String name, String addr) {
        this.id = id;
        this.name = name;
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "DataTest{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", addr='" + addr + '\'' +
                '}';
    }
}

以下是对数据的初始化

				List<DataTest> list = new ArrayList<>();
        for (int i = 0; i < 10; i++){
            DataTest dataTest = new DataTest();
            dataTest.setId(i);
            dataTest.setName("test"+i);
            dataTest.setAddr("hanzhou"+i);
            list.add(dataTest);
        }

Filter过滤

关于filter()操作，它是一个断言的中间操作 (ps: 中间操作指的是我们可以对其返回值继续进行操作，而对应的终端操作返回的是void我们就不能继续操作下去了)，它的作用是帮我们筛选出需要的集合元素。

public static void filterTest(List<DataTest> list){
        list
                .stream()
                .filter((data) -> data.getId() >= 5)
                .forEach(System.out::println);
    }

对应输出结果

DataTest{id=5, name='test5', addr='hanzhou5'}
DataTest{id=6, name='test6', addr='hanzhou6'}
DataTest{id=7, name='test7', addr='hanzhou7'}
DataTest{id=8, name='test8', addr='hanzhou8'}
DataTest{id=9, name='test9', addr='hanzhou9'}

Sorted排序

sorted() 同样也是中间操作。 可以传入一个 comparator 来自定义排序

public static void sortedTest(List<DataTest> list){
        list
                .stream()
                .sorted((a,b) -> b.getId() - a.getId())
                .forEach(System.out::println);
    }public static void mapTest(List<DataTest> list){
        list
                .stream()
                .map(archive -> test1TurnTOTest2(archive))
                .forEach(System.out::println);
    }

    public static void collectTest(List<DataTest> list){
        final Map<Integer, String> collect = list
                .stream()
                .collect(Collectors.toMap(DataTest::getId, DataTest::getName));
    }

输出结果

DataTest{id=9, name='test9', addr='hanzhou9'}
DataTest{id=8, name='test8', addr='hanzhou8'}
DataTest{id=7, name='test7', addr='hanzhou7'}
DataTest{id=6, name='test6', addr='hanzhou6'}
DataTest{id=5, name='test5', addr='hanzhou5'}
DataTest{id=4, name='test4', addr='hanzhou4'}
DataTest{id=3, name='test3', addr='hanzhou3'}
DataTest{id=2, name='test2', addr='hanzhou2'}
DataTest{id=1, name='test1', addr='hanzhou1'}
DataTest{id=0, name='test0', addr='hanzhou0'}

Map 转换

同上map()也是一个中间操作，其作用是将 一个对象转换成另一个对象

		public static void mapTest(List<DataTest> list){
        list.stream()
                .map(archive -> test1TurnTOTest2(archive))
                .forEach(System.out::println);
    }

    public static DataTest2 test1TurnTOTest2(DataTest dataTest){
        DataTest2 dataTest2 = new DataTest2();
        dataTest2.setId(dataTest.getId());
        dataTest2.setName(dataTest.getName());
        return dataTest2;
    }

输出结果

DataTest2{id=0, name='test0'}
DataTest2{id=1, name='test1'}
DataTest2{id=2, name='test2'}
DataTest2{id=3, name='test3'}
DataTest2{id=4, name='test4'}
DataTest2{id=5, name='test5'}
DataTest2{id=6, name='test6'}
DataTest2{id=7, name='test7'}
DataTest2{id=8, name='test8'}
DataTest2{id=9, name='test9'}

Collect组装集合操作

collect() 此操作是一个终端操作，功能是将流组装成集合。

	public static void collectTest(List<DataTest> list){
        final Map<Integer, String> collect = list
                .stream()
								//collect中可以使用 Collectors转换不同的对象
                .collect(Collectors.toMap(DataTest::getId, DataTest::getName));
    }

Match匹配

match() 也是一个终端操作，用来匹配其中是否有符合要求的元素，返回的值为 boolean类型。

其中有 anyMatch() 包含任意一个 allMatch() 所有的都包含 noneMatch() 所有的都不包含

public static void matchTest(List<DataTest> list){
        Boolean flag = list
                .stream()
                .anyMatch((data) -> data.getId() == 29);
        System.out.printf(flag+"");
    }

输出为 false

Count计数

match() 也是一个终端操作，统计流中的元素个数，返回的值为 long类型。可以配合其它的方法使用，如filer()

public static void countTest(List<DataTest> list){
        long count = list
                .stream()
                .filter((data) -> data.getId() >= 5)
                .count();
        System.out.printf("conut=" + count);
    }

---

以上就是个人觉得stream中用的比较多的方法，在之后的学习中可能还会补充