Jdk1.8 Stream

jdk1.8已经发布好几年了，最新的已经发布到jdk12了，但是目前开发种还是jdk1.8用到的较多，最近在工作种用到了Stream，在这做个笔记整理学习。

什么是Stream

Stream是java8的新特性，位于包java.util.stream,但是和java的iostream完全不同，是对集合功能的增强，可以进行大批量的数据操作，分为并行和串行操作，结合java8 lambda表达式使用

使用步骤

获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。
有多种方式生成 Stream Source：

从 Collection 和数组

Collection.stream() //串行流
Collection.parallelStream() // 并行流
Arrays.stream(T array) or Stream.of()
从 BufferedReader

java.io.BufferedReader.lines()
静态工厂
java.util.stream.IntStream.range()
java.nio.file.Files.walk()
自己构建

java.util.Spliterator
其它
Random.ints()
BitSet.stream()
Pattern.splitAsStream(java.lang.CharSequence)
JarFile.stream()

常用操作

filter

过滤器，使用该方法过滤stream中的数据

List<Person> list = new ArrayList<>();
        list.add(new Person("jack", 20));
        list.add(new Person("mike", 25));
        list.add(new Person("tom", 30));

        /**
         * stream filter
         * x -> x.getAge() == 20  过滤条件保留年龄为20的用户
         * 输出结果 [Person(name=jack, age=20)]
         */
        list = list.stream().filter(x -> x.getAge() == 20).collect(Collectors.toList());
        System.out.println(list);

distinct

去除重复数据，注意stream中的对象需要重写equal和hashcode方法

@Data

@AllArgsConstructor
@NoArgsConstructor
public class Person implements Comparable<Person> {

    private String name;
    private int age;

    @Override
    public int compareTo(Person o) {
        return age-o.getAge();
    }
}

        list = new ArrayList<>();
        list.add(new Person("jack", 20));
        list.add(new Person("mike", 25));
        list.add(new Person("jack", 20));
        list.add(new Person("tom", 30));

        System.out.println(list);
		
        List<Person> list1 = list.stream().distinct().collect(Collectors.toList());
        System.out.println(list1);

输出结果
此时new Person(“jack”, 20) 只保留了一条数据，去除了相同的数据

[Person(name=jack, age=20), Person(name=mike, age=25), Person(name=jack, age=20), Person(name=tom, age=30)]
[Person(name=jack, age=20), Person(name=mike, age=25), Person(name=tom, age=30)]

sorted

用于对stream中的数据排序，有三种方式
1.stream中对象实现java.lang.Comparable 接口，
2.也可以写内部类实现接口调用java.util.Comparator
3. 调用java.util.Comparator的抽象方法

	// 1. 对象实现java.lang.Comparable 接口
        List<Person> list2 = list.stream().sorted().collect(Collectors.toList());
        System.out.println(list2);
//2 内部类实现接口调用java.util.Comparator
        List<Person> list3 = list.stream().sorted((p1, p2) -> p1.getAge() - p2.getAge()).collect(Collectors.toList());
        System.out.println(list3);

//3 调用java.util.Comparator的方法
        list.stream().sorted(Comparator.comparingInt(Person::getAge));

limit

返回前n个数据

       List<Person> list4 = list.stream()
                .limit(2)
                .collect(Collectors.toList());

        System.out.println(list4);
        System.out.println("----------------");

skip

去除前n个数据

     List<Person>  list5 = list.stream()
                .skip(2)
                .collect(Collectors.toList());
        System.out.println(list5);
        System.out.println("----------------");

map

map(T -> R) 将流中的每一个元素 T 映射为 R（类似类型转换）
这个是将listz person中name转换成单独的list
可以从数据库中查询出数据，然后再将某一列单独提取出来

	// 将person中name字段单独提取出来，作为list
        List<String> nameList = list.stream().map(Person::getName).collect(Collectors.toList());

        System.out.println(nameList);
	// 将name字段分别+aa
        List<String> collect = nameList.stream().map(x -> x + "aa").collect(Collectors.toList());
        System.out.println(collect);

        System.out.println("----------------");
//将字符串分隔成字符数组，在合并为一个list 
        List<String> listS = new ArrayList<>();
        listS.add("aaa bbb ccc");
        listS.add("ddd eee fff");
        listS.add("ggg hhh iii");
//collect1 
        List<String[]> collect1 = listS.stream().map(s -> s.split(" ")).collect(Collectors.toList());

        collect1.forEach(strings -> Arrays.asList(strings).forEach(System.out::println));
        System.out.println(collect1);

输出结果

----------------
[jack, mike, jack, tom]
[jackaa, mikeaa, jackaa, tomaa]

aaa
bbb
ccc
ddd
eee
fff
ggg
hhh
iii
collect1 的大小=3

flatMap(T -> Stream)

将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流

        List<String> listS = new ArrayList<>();
        listS.add("aaa bbb ccc");
        listS.add("ddd eee fff");
        listS.add("ggg hhh iii");

        List<String[]> collect1 = listS.stream().map(s -> s.split(" ")).collect(Collectors.toList());

        collect1.forEach(strings -> Arrays.asList(strings).forEach(System.out::println));
        System.out.println("collect1 的大小="+collect1.size());

      /**
         * ，我们的目的是把 List 中每个字符串元素以" "分割开，变成一个新的 List<String>。
         * 首先 map 方法分割每个字符串元素，但此时流的类型为 Stream<String[ ]>，
         * 因为 split 方法返回的是 String[ ] 类型；所以我们需要使用 flatMap 方法，先使用Arrays::stream将每个 String[ ] 元素变成一个 Stream<String> 流，
         * 然后 flatMap 会将每一个流连接成为一个流，最终返回我们需要的 Stream<String>
         */
        List<String> list6 = listS.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());

        System.out.println(list6);
// 输出结果 [aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii]

anyMatch

anyMatch(T -> boolean)
流中是否有一个元素匹配给定的 T -> boolean 条件

//匹配年龄为20的
 boolean b = list.stream().anyMatch(person -> person.getAge() == 20);
        System.out.println(b);

allMatch

流中是否所有元素都匹配给定的 T -> boolean 条件

        boolean b1 = list.stream().allMatch(person -> person.getAge() == 20);
        System.out.println(b1);

noneMatch(T -> boolean)

流中是否没有元素匹配给定的 T -> boolean 条件

        boolean b2 = list.stream().noneMatch(person -> person.getAge() == 20);
        System.out.println(b2);

findAny findFirst

findAny()：找到其中一个元素 （使用 stream() 时找到的是第一个元素；使用 parallelStream() 并行时找到的是其中一个元素）
findFirst()：找到第一个元素
值得注意的是，这两个方法返回的是一个 Optional 对象

Optional<Person> any = list.stream().findAny();
        Person person = any.get();

        System.out.println(person.getAge());

        Optional<Person> first = list.stream().findFirst();
        Person person1 = first.get();
        System.out.println(person1.getAge());

reduce

reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)
用于组合流中的元素，如求和，求积，求最大值等

 list.stream().map(Person::getAge).reduce(0,Integer::sum);
        list.stream().map(Person::getAge).reduce(Integer::sum);
        list.stream().map(Person::getAge).reduce(0,(a,b3)-> a+b3); // （a,b） 是在整个{}范围内生效，假设说定义一个private String a, 则会和（a.b ）有冲突

count

返回流中元素个数，结果为 long 类型

        List aa = null;
        long count = list.stream().count();
        System.out.println(count);
        System.out.println("----------------");

unordered()

返回一个等效的无序流，
当然如果流本身就是无序的话，那可能就会直接返回其本身