[Java知识库]Stream

Stream

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把 它看作是遍历数据集的高级迭代器。与 stream 与 lambada 表达示结合后 编码效率与大大提高，并且可读性更强。

注意: java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念.

什么是流呢？

简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。

元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。

数据源 :获取数据的源，比如集合。

数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。

简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一 系列流操作，最后再构建成我们需要的数据集合。

获取流

使用 Collection 接口下的 stream()

 List<String> list = new ArrayList<>(); 
 
Stream<String> stream = list.stream(); 

使用 Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10]; 

Stream<Integer> stream = Arrays.stream(nums); 

使用 Stream 中的静态方法：of()

Stream<Integer> stream = Stream.of(1,2,3,4,5,6); 

使用 BufferedReader.lines() 方法，将每行内容转成流

 BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
 
 Stream<String> lineStream = reader.lines();

流操作

流操作可以分为两类：中间操作和终端操作。

中间操作

package com.ff.javaforword.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Demo1 {
    public static void main(String[] args) {
        //中间操作
       /* List list= new ArrayList();
        list.stream();

        int array [] = new int [10];
        Arrays.stream(array);*/

       /* Stream.of(5,6,8,9,1,3,6,4)
                .filter((e)->{return e>3;})
                .sorted().forEach((a)->{
            System.out.println(a);
        });
*/
        /*Stream.of(5,6,8,9,1,3,6,4)
                .distinct()
                .sorted().forEach((a)->{
            System.out.println(a);
        });*/
       Stream.of(5,6,8,9,1,3,6,4)
                .sorted()
                .distinct()
                .skip(0)
                .limit(2)
                .sorted().forEach((a)->{
            System.out.println(a);
        });    
}

终端操作

package com.ff.javaforword.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Demo1 {
    public static void main(String[] args) 
        //终端操作
        //Max:返回流中元素最大值 返回值为optional时候需要get
      /* Object m= Stream.of(5,6,8,9,1,3,6,4)
                .sorted()
                .distinct()
                .max((o1,o2)->{return o1-o2;}).get();
            System.out.println(m);*/
        //count:返回流中元素的总个数
       /* Long count = Stream.of(5,6,8,9,1,3,6,4)
                .distinct()
                .count();
        System.out.println(count);
*/
        //Reduce:所有元素求和
        /*Integer sum = Stream.of(5,6,8,9,1,3,6,4)
                .distinct()
                .reduce((o1,o2)->{return o1+o2;})
                .get();
            System.out.println(sum);*/
        //anymuch接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
        /*boolean res = Stream.of(5,6,8,9,1,3,6,4)
                .distinct()
                .anyMatch((e)->{return e>3;});
        System.out.println(res);*/

        //allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
        boolean res = Stream.of(5, 6, 8, 9, 1, 3, 6, 4)
                .distinct()
                .allMatch((e) -> {
                    return e > 3;
                });
        System.out.println(res);
    }
}

案例2:

package com.ff.javaforword.stream;

public class Apple {
    private  Integer num;
    private String name;
    private String color;

    @Override
    public String toString() {
        return "Apple{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    public Apple(){

    }
    public Apple(int num, String name, String color) {
        this.num = num;
        this.name = name;
        this.color = color;
    }

    public  int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

package com.ff.javaforword.stream;

import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<Apple> list = new ArrayList<>();
        list.add(new Apple(100, "ping1", "red"));
        list.add(new Apple(34, "ping2", "bule"));
        list.add(new Apple(56, "ping3", "yellow"));
        list.add(new Apple(120, "ping4", "red"));
        list.add(new Apple(21, "ping5", "black"));
        //map方法,将值映射到stream中
      /*  list.stream()
                .map(Apple::getNum)
                .forEach((e) -> {
                    System.out.println(e);
                });
*/
       /* Set<Apple> list1 = list.stream()
                .sorted((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                })
                .collect(Collectors.toSet());
        System.out.println(list1);
*/
       /* List<Apple> list1 = list.stream()
                .sorted((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                })
                .collect(Collectors.toList());
        System.out.println(list1);
*/
        Map<Integer, String> map = list.stream()
                .sorted((o1, o2) -> {
                    return o1.getNum() - o2.getNum();
                })
                .collect(Collectors.toMap(Apple::getNum, Apple::getName));
        System.out.println(map);

    }
}