Stream流运算和链式编程

目录

步骤1.创建流，把数据转换成流

步骤2.中间的操作，比如filter，map等，对数据进行操作(链式编程)

筛选与切片

映射：

排序

步骤3：终止操作

查找和匹配：

归约：

收集：

---

集合的使用主要和内存有关，而Stream主要和cpu有关

官方概念：支持顺序和并行操作的一系列元素。

Stream文档中方法很多都是函数式接口，所以在写的时候可以通过lambda表达式

主要分三步骤，1.创建流，2操作流，3终止流

步骤1.创建流，把数据转换成流

集合：

stream:顺序流，按照集合的顺序从上往下执行 

parallelStream：并行流，里面的数据相当于线程，一起执行，看谁先拿到cpu资源

//创建了一个集合        
List<Student> students = Arrays.asList(s1, s2, s3, s4,s5);
//转换为stream流，并计算
 students.stream().forEach(System.out::println);

数组：

        int[] arrs1 = new int[10];
        long[] arrs2 = new long[10];
        Double[] arrs3 = new Double[10];
        IntStream stream = Arrays.stream(arrs1);
        LongStream stream1 = Arrays.stream(arrs2);
//      stream类型通过泛型的方式体现
        Stream<Double> stream2 = Arrays.stream(arrs3);

通过Stream的of()创建：

里面方法相当于包装类的对象

Stream<Integer> s = Stream.of(1, 2, 3, 4);

创建无限流

这个用的少，这里不介绍了，但是得知道有这东西

步骤2.中间的操作，比如filter，map等，对数据进行操作(链式编程)

筛选与切片

filter(Predicate p) 排除某些元素

distinct() 筛选，通过流生成hashCode()和equals()去除重复元素

limit(long maxSize)截断流，使元素不超过给定数量

skip(long n)跳过元素，返回一个扔掉的前n个元素的流，若流元素中不超过n个则返回一个空流

public class Test1 {
    public static void main(String[] args) {
        Student s1 = new Student(1, "sam", 11, 1, 7600);
        Student s2 = new Student(2, "Amy", 12, 0, 9000);
        Student s3 = new Student(3, "Daming", 10, 1, 8760);
        Student s4 = new Student(4, "LingLing", 9, 0, 8706);
        Student s5 = new Student(6, "Jack", 14, 1, 18706);
        Student s6 = new Student(6, "Jack", 14, 1, 18706);//重复了。但被去重了
        Student s7 = new Student(6, "Jack", 15, 1, 18706);//重复但又没完全重复
        List<Student> students = Arrays.asList(s1, s2, s3, s4, s5,s6,s7);
        students.stream().
                filter((u)->u.getId()%2==0)
                .filter((u)->u.getAge()>10)
                .limit(5)//限制出5个
                .distinct()
                .forEach(System.out::println);


    }
}

映射：

map(Function f)：返回一个新的流

        List<Student> students = Arrays.asList(s1, s2, s3, s4, s5,s6,s7);
        students.stream()
                .map(Student::getName)//会返回一个新的流，这个流里面全都是名字
//                .filter(n->n.getName().length()>3)
                .forEach(System.out::println);

flatMap(Function f)

public class Test1 {
    public static void main(String[] args) {
        Student s1 = new Student(1, "sam", 11, 1, 7600);
        Student s2 = new Student(2, "Amy", 12, 0, 9000);
        Student s3 = new Student(3, "Daming", 10, 1, 8760);
        Student s4 = new Student(4, "LingLing", 9, 0, 8706);
        Student s5 = new Student(6, "Jack", 14, 1, 18706);
        Student s6 = new Student(6, "Jack", 14, 1, 18706);
        Student s7 = new Student(6, "Jack", 15, 1, 18706);
        List<Student> students = Arrays.asList(s1, s2, s3, s4, s5, s6, s7);
        Stream<String> list= students.stream().map(Student::getName);
//流中流
        Stream<Stream<Character>> streamStream = list.map(Test1::fromStringToStream);
        streamStream.forEach(s->{
            s.forEach(System.out::println);
        });
    }

    public static Stream<Character> fromStringToStream(String str) {
        ArrayList<Character> s = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            s.add(c);
        }
        return s.stream();
    }
}

简化：

public class Test1 {
    public static void main(String[] args) {
        Student s1 = new Student(1, "sam", 11, 1, 7600);
        Student s2 = new Student(2, "Amy", 12, 0, 9000);
        Student s3 = new Student(3, "Daming", 10, 1, 8760);
        Student s4 = new Student(4, "LingLing", 9, 0, 8706);
        Student s5 = new Student(6, "Jack", 14, 1, 18706);
        Student s6 = new Student(6, "Jack", 14, 1, 18706);
        Student s7 = new Student(6, "Jack", 15, 1, 18706);
        List<Student> students = Arrays.asList(s1, s2, s3, s4, s5, s6, s7);
        Stream<String> list= students.stream().map(Student::getName);
//        简化循环->循环
        list.flatMap(Test1::fromStringToStream).forEach(System.out::println);

    }

    public static Stream<Character> fromStringToStream(String str) {
        ArrayList<Character> s = new ArrayList<>();
        for (Character c : str.toCharArray()) {
            s.add(c);
        }
        return s.stream();
    }
}

排序

sorted()：产生一个新流，其中按自然顺序排序

//默认从小到大
list.stream().map(Student::getSalary).sorted().forEach(System.out::println);

sorted(Comparator com):返回一个心流，其中按比较顺序排序

//自己可以定制方法
list.stream().map(Student::getSalary).sorted((a, b) -> Long.compare(b, a)).forEach(System.out::println);

步骤3：终止操作

在步骤二中如果没有调用步骤3，都是不执行的，它具有延迟性。当步骤三开始执行的时候，步骤二才开始执行

比如：

查找和匹配：

 boolean allMatch(Predicate p):检查是否匹配所有元素

boolean anyMatch(Predicate p):检查是否至少匹配一个元素

 boolean noneMatch(Predicate p): 检查是否没有匹配所有元素

Optional findFist(）:返回第一个元素

Optional findAny(): 返回当前流的所有元素

int count（）：返回流中元素总数

max(Comparator c)返回流中最大值

max(Comparator c)返回流中最小值

imit（）:限制多少个

forEach()：内部迭代

归约：

map-reduce

reduce(T iden,BinaryOperator b) 流中元素反复结合起来，得到一个值，返回T T+总和

reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值，返回Optional 总和

收集：

collect(Collector c)  将流转换成其他形式，接受Collector接口的实现，用于给Stream中元组做汇总的方式

补充：collectors方法

toList 返回List集合

toSet set

toCollection 把流元素收集到创建的集合中