java8--stream

1、什么是Stream？

• Stream是java8的新特性，它允许你以声明式的方式处理数据集合，可以看做是遍历数据集的高级迭代器。
• stream与lambda 表达式结合后编码效率提高，可读性增强。
  eg：
• 定义一个苹果类

package database.stream;

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

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

    public Apple() {
    }

    public int getNum() {
        return num;
    }

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

    public String getColor() {
        return color;
    }

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

    public String getName() {
        return name;
    }

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

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

• 在集合中添加元素

    public static void main(String[] args) {
        ArrayList<Apple> list =new ArrayList<>();
        list.add(new Apple(1,"红色","苹果1"));
        list.add(new Apple(3,"粉色","苹果3"));
        list.add(new Apple(4,"绿色","苹果4"));
        list.add(new Apple(2,"白色","苹果2"));

• 在集合中输出苹果的名字
  
• 上面的例子就是java8中的stream流，使用时声明性方式写的：说明想要完成什么（筛选，排序，取值），而不是说明如何实现一个操作（for循环）。同时将这些操作链接起来，如图：
  

2、什么是流呢？

• 从支持数据处理操作的源，生成的元素序列

3、元素列表

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

4、数据源

获取数据的源，比如集合

5、数据处理操作

流更偏向于数据处理和计算，比如 filter 、map 、find 、sort等。简单来说，通过一个集合的stream方法获取一个流，对流进行操作，在形成数据集合。

6、获取流

• 使用Collection接口下的stream（）

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

• 使用Arrays中的stream（）方法，将数组转为流

  Integer [] arr =new  Integer[10];
        Arrays.stream(arr);

• 使用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();

7、流操作

   			list.stream()              //获得流
                .map(Apple::getName)   //中间操作
                .forEach((a)->{        //终端操作
                    System.out.println(a);
                });

数据源 => 中间操作 => 终端操作 => 结果

8、中间操作

• filter：过滤流中的某些元素,
• sorted(): 自然排序，流中元素需实现 Comparable 接口
• distinct: 去除重复元素
• limit(n): 获取 n 个元素
• skip(n): 跳过 n 元素，配合 limit(n)可实现分页
• map(): 将其映射成一个新的元素

9、终端操作

• forEach: 遍历流中的元素
• toArray:将流中的元素倒入一个数组
• Min:返回流中元素最小值
• Max:返回流中元素最大值
• count:返回流中元素的总个数
• Reduce:所有元素求和
• anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false
• allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false
• findFirst：返回流中第一个元素
• collect:将流中的元素倒入一个集合,Collection 或 Map

10、一些案例

• 去重，并获取最小值
  
• 去重，并获取数组长度
  
• 去重，并获取最大值
  
• 去重，获取总数
  
• 去重，求所有元素和
  
• 去重，要求所有元素大于3，才能返回true，否则，返回false
  
• 去重，任意一个元素大于2，返回true，否则返回false
  
• 返回最上面的苹果案例
• 将map（）操作转为set集合

     Set<Apple> apples=list.stream()
                .filter((a)->{return a.getNum()>2;})
                .collect(Collectors.toSet());
        System.out.println(apples);

• 将map（）操作转为list集合

 List<Apple> apple=list.stream()
                .sorted((o1,o2)->{return o1.getNum()-o2.getNum();})
                .collect(Collectors.toList());
        System.out.println(apple);

• 将map（）操作转为map集合

    Map<Integer,String> app=list.stream()
                .filter(apple1 -> {return apple1.getNum()>1;})
                .collect(Collectors.toMap(Apple::getNum,Apple::getColor));
        System.out.println(app);