Java之Stream流的使用

使用好JDK8的新特性会有助于你的编程，Stream流的使用会使集合或数组的操作更加简便，更赏心悦目，相信这篇文章可以使喜欢追求细节完美的人会有所收获。

Java中什么是Stream(流)

Stream是java的1个类, 这个类专门用于程序和外部设备的输入输出(IO). 基本上所有流都在 java.io这个包中.
实际上Stream就是数据在程序和外部设备的单向管道, 流的各种方法相当于管道上的各种按钮.
所谓的外部设备可以包括硬盘文件, 网络设备, 另个程序等. 也就是当前程序之外的数据设备.

要注意再流中操作数据不能影响到原数据 把流理解成为快捷展示的过程或许好理解些（例如看电影）

为什么需要Stream(流)

Stream存在的意义也很简单.

1. 数据的传输量很大.

2. 内存有限.

3. 带宽有限.

而Stream可以1点1点地逐步传输所有数据, 这就是Stream存在的根本意义.

下面简单介绍一下Java中stream流的使用：

1.获取stream流

方式a：根据Collection获取流
List集合创建创建：调用List的stream方法即可，如 list.stream()

方式b：根据Map获取流
Stream> entryStream = map.entrySet().stream();

方式c：根据静态方法获取流
Stream stream = Stream.of(new Integer[]{1,2});

注：stream流被创建出来之后只能被使用一次，如需再次循环需要再次创建！

2.常用方法介绍：

流的方法被分为中间操作和终端操作，顾名思义，中间操作是指调用方法后生成新的流，可以继续执行操作，而终端操作则是结束流的使用。

中间操作：

1.filter　Stream filter(Predicate predicate);　过滤掉不符合的数据

2.limit　Stream limit(long maxSize);　只取前x条数据

3.skip　Stream skip(long n);　跳过（删除）x条数据

4.distinct　　去重复数据

5.sorted　　排序

6.map　 Stream map(Function mapper);　对数据重整，生成新的数据流（如何从用户集合流中取出用户年龄作为新的流）

终端操作：

1.count　long count();　统计数据数量

2.forEach　void forEach(Consumer action);　对流中每个数据都执行传入的方法

3.anyMatch　　至少一个匹配，返回bool

4.allMatch　　匹配所有，返回bool

5.collect　　可以传入集合中的常用方法，例如：Collectors.toList()将流转回集合（Collects.toSet）收集为Set | (Collectors.toMap)收集为Map;
public static Collector toList() ：
public static Collector toSet()

6.toArray 转换成数组
Object[] toArray();

Stream的方法:
1.Stream.of(); 获取流形式的对象
2.Stream.concat(stream1, stream2) static Stream concat(Stream a, Stream b) 流合并 （会影响原对象）

流的一些操作实例

        package com.youngchan.practice;

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class Practice {
    public static void main(String[] args) {

        // 使用foreach 遍历的两种方式  方式一
        System.out.println("zero~~~~~~~~~~~~~~~~~~");
        List list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张san");
        list.add(" 张 三 丰  ");
        list.forEach((a)-> System.out.println(a));
        // 方式二
        System.out.println("one~~~~~~~~~~~~~~~~~~");
        list.forEach((a)->{
            if(a.trim().startsWith("张")){
                System.out.println(a);
            }
        });
        //使用 filter进行过滤
        System.out.println("two~~~~~~~~~~~~~~~~~~");
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==4).forEach(System.out::println);


        // 使用distinct 去重 ， map进行拆解筛选对象属性，collect进行收集
        System.out.println("three~~~~~~~~~~~~~~~~~~");
        list.add("张无忌");
        list.stream().filter(s -> s.trim().startsWith("张")).distinct().map(s -> s.toUpperCase()).collect(Collectors.toList()).forEach(System.out::println);

        // 使用count 统计个数
        System.out.println("four~~~~~~~~~~~~~~~~~~");
        System.out.println(list.stream().distinct().count());

        // 使用limit 过滤
        System.out.println("five~~~~~~~~~~~~~~~~~~");
        list.stream().limit(1).forEach(System.out::println);

        // 使用skip 过滤  distinct 和skip连用会用小问题（distinct不改变原集合）
        System.out.println("six~~~~~~~~~~~~~~~~~~");
        System.out.println(list.stream().distinct().collect(Collectors.toList()).stream().count());
        list.stream().distinct().collect(Collectors.toList()).stream().skip(3).limit(1).forEach(System.out::println);


        //使用concat组合  组合后会改变原集合数据
        System.out.println("seven~~~~~~~~~~~~~~~~~~");
        List list2 = new ArrayList<>();
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("沙和尚");
        list.add("唐三藏");
        list.add("白龙马");
        Stream> Slist = Stream.of(list);
        Stream> Slist2 = Stream.of(list2);
        List> result = Stream.concat(Slist, Slist2).filter((a) -> !a.isEmpty()).distinct().collect(Collectors.toList());
        System.out.println(list2.size());
        System.out.println(list.size());
        list.forEach(System.out::println);


        // sorted 排序
        System.out.println("eight~~~~~~~~~~~~~~~~~~");
        list.stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);


        // 是否存在 anyMath 匹配  全部是 allMatch 全匹配
        System.out.println("nine~~~~~~~~~~~~~~~~~~");
        System.out.println(list.stream().anyMatch(Predicate.isEqual("孙悟空")));
        System.out.println(list.stream().allMatch(Predicate.isEqual("孙悟空")));


        // 集合排序生成新集合
        System.out.println("ten~~~~~~~~~~~~~~~~~~");

        ArrayList students = new ArrayList<>();
        list.remove(0);
        for (int i = 0; i < list.size(); i++) {
            students.add(new Student(i+ new Random().nextInt(20),list.get(i)));
        }
        System.out.println("排序前学生集合");
        students.forEach((a)-> System.out.print(a+"   ~   "));
        System.out.println("排序后学生集合");
//        Map map = students.stream().sorted((a, b) -> b.getAge() - a.getAge()).collect(Collectors.toMap(Student::getAge, Student::getName));
        Map map = students.stream().sorted((a, b) -> b.getAge() - a.getAge()).collect(Collectors.toMap(Student::getName, Student::getAge));
        System.out.println(map);
        List sortedStudent = students.stream().sorted((a, b) -> a.getAge() - b.getAge()).collect(Collectors.toList());
        sortedStudent.forEach((a)-> System.out.print(a+"   ~   "));


    }

}

实体类

package com.youngchan.practice;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Comparator;
import java.util.Objects;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Comparator{
   private int age;
   private String name;

    @Override
    public int compare(Object o1, Object o2) {
        Student s1 = (Student) o1;
        Student s2 = (Student) o2;
        return s1.getAge()-s2.getAge();
    }
}