Stream流

这里有一个集合

List<Integer> list = Arrays.asList(1,2,3,4,5);

我们要写一个方法找偶数，返回一个新的list包含结果；
用我们以前的方法做的话就会比较繁琐：

public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        System.out.println(exec(list, new Predicate<Integer>(){
            @Override
            public boolean test(Integer i) {
                return i % 2 == 0;
            }
        }))；
        //System.out.println(exec(list, i ->  i % 2 == 0))；
    }
    // 设计模式中，策略模式
    public static List<Integer> exec(List<Integer> list, Predicate<Integer> predicate) {
        List<Integer> list2 = new ArrayList<>();
        for(Integer i :list) {
            if(predicate.test(i)) {
                list2.add(i);
            }
        }
        return list2;
    }

在这里我们使用了设计模式中的策略模式，将它的处理方法拿出来，可以对它的使用方法进行主动的编写，同时我们用了一个新的模式Predicate，这个模式叫做断言模式，顾名思义就是对我们要进行的处理进行断言操作，断定它能进行的功能；比如上面的例子就是我们求出了list集合中所有的偶数，那我们如果不想对他进行求偶操作呢？比如我们想求出集合中所有大于三的数据呢？
这个时候我们就可以改变这个断言，重新写入想要的操作；

 System.out.println(exec(list, new Predicate<Integer>(){
            @Override
            public boolean test(Integer i) {
                return i >3;
            }

在不用断言模式的时候，我们甚至需要新写一个方法，然后调用它，有了断言模式，我们就可以主动的给exec这个方法传入我们想要的策略；
甚至我们可以对断言进行简写；即lambda表达式；

这里我们可以看到这个接口是一个函数式接口，就是单方法接口；所以我们完全可以用lambda表达式给他写入断言；

System.out.println(exec(list,i -> i % 2 == 0);
System.out.println(exec(list,i -> i > 3);

用了lambda表达式就大大减少了我们的代码量;
可是这也是比较麻烦的 ；而且在之前我们遍历集合的时候就需要循环，或者 Iterator 迭代器来遍历；这也都是很浪费时间和空间的；
那有没有一种方法，是我们不用调用方法，直接用语句来获得所有的偶数呢？这个时候我们就需要用到jdk1.8的新特性，Stream流，将数组元素变为一条数据流，然后对这个数据流进行操作，过滤或者收集想要的数据；

• 特点：

1. Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

2. Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

3. Stream 的数据源本身可以是无限的。

1. filter （过滤器）
   这个过滤器的方法就是对流中的数据一个一个的进行筛选，看看它是不是符合规则，如果不符合就拦截住，也就是舍弃，如果符合要求，则让他通过，进行下一步的操作，说白了就像一个滤网一样，我们可以设置过滤的规则，然后它对数据流进行筛选；
   比如上面的例子来说我们就可以用这样的方法；

List<Integer> list = Arrays.asList(1,2,3,4,5,6);
List<Integer> stream = list.stream().filter( i -> 
		i%2  == 0).collect(Collectors.toList());
System.out.print(stream);

我们可以看到filter的参数就是一个Predicae<>断言；也就是说我们可以给它里面传一个lambda表达式，就是过滤的规则； 同时它返回的又是一个Stream流对象，这时我们又可以用它的collect（收集器），对过滤下来的数据收集起来，把他存入一个List集合；然后这时候我们输出得到的这个集合，就是我们收集的数据；

2. map （映射）
   映射的, lambda把原有的元素转换为另一个元素， 不会改变个数；
   上面的filter过滤器就是给把我们的数据按我们的规则筛选出来，那map()方法就是将我们的元素按照规则映射成另外的元素；比如我们要得到上面的list集合中的所有元素的2倍的集合，这时候我们就需要用到map(）方法；

	List<Integer> list4 = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> collect = list4.stream().map(i -> 
        i * 2).collect(Collectors.toList());
        System.out.println(collect);

这只是简单的映射，我们又得到了需要的数据，同时原集合仍然存在；我们再看看map（）方法的参数；

这里我们需要一个Function()参数，这个模式的方法lambda表达式的写法就是一个参数，返回一个结果；

	map(i ->  i * 2)

这句映射就很直观的帮我们解释了Function接口的特性；

3. == flatMap(扁平化映射)==
   这个类就好比是流的类型转换；
   比如我们现在定义了一个list集合，它的元素是字符串数组；

List<String[]> list = new ArrayList<>();
        list.add(new String[]{"张三", "李四"});
        list.add(new String[]{"王五", "张三"});
        list.add(new String[]{"钱七", "周八"});

如果我们想将它里面的每个字符串提取出来，组成一个新的集合，按照原来的方法我们就需要两重遍历，先遍历集合，后遍历数组，得到每一个字符串元素，再新建一个集合，将它们存进去；

 List<String> list2 = new ArrayList<>();

        for (String[] strings : list) {
            for (String string : strings) {
                list2.add(string);
            }
        }
        System.out.println(list2);

可如果用flatmap方法做扁平化映射时就特别简单，我们一句话就可以得到这个集合；

List<String> list3 = list.stream().flatMap( s -> 
Arrays.stream(s)).collect(Collectors.toList());

flatmap的参数同样是一个Function，只是这次我们传入的参数是list集合的元素String[]数组，把它映射成一个数组流Arrays.stream，然后collect收集起来；这个方法就很方便；
它就可以用在我们平时大规模数据转换的时候，用流的方式，得到需要的格式；

4. forEach
   遍历流，接收一个Consumer

list3.stream().forEach( (a) -> {
    System.out.println(a);
} );

5. map的流遍历
   接收一个BiConsumer

Map<String, String> map = new HashMap<>();
map.put("a", "张");
map.put("b", "李");
map.forEach( (key, value) -> {
    System.out.println("key:" +key + " value:" + value);
} );

上面说了很多种的模式，再这里我们统一进行一下说明；

1. Predicate 断言接口
   对应的lambda 一个参数，返回结果是boolean
   (a) -> { return true|false; }

2. BiPredicate 双参数断言
   对应的lambda 两个参数，返回结果是boolean
   (a, b) -> { return true|false; }

3. Function 函数接口
   对应的lambda 一个参数，一个返回结果，参数和返回结果的类型可以不一样

4. BiFunction 双参数函数接口
   两个参数，一个结果
   (a, b) -> { 根据ab返回一个结果}

5. Consumer 消费接口
   一个参数 没有结果
   (a) -> { 不需要return }

6. BiConsumer 双参数消费接口
   两个参数，没有结果
   (a,b) -> { 不需要return }

7. Supplier 生产者接口
   没有参数，返回一个结果
   () -> {return 结果}
   有了这些模式知识的帮忙我们就可以更好的理解Stream()中方法的参数需求了；

求个数count()

System.out.println(list3.stream().count());

去除重复distinct（）

System.out.println(list3.stream().distinct().collect(toList()));

获取最大最小值（参数需要一个比较器）

// 返回的是Optional 类型，怕集合为空时，没有合法的最大值
List<String> list4 = Arrays.asList("zhang", "li", "zhao", "wang"); 
System.out.println(list4.stream().max((a, b) -> a.compareTo(b)));
System.out.println(list4.stream().min((a, b) -> a.compareTo(b)));

如果是数字流，除了最大最小值外，还有平均值，和

System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).max());
System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).min());
System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).average());
System.out.println(IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).sum());

有了上面的知识我们来做一个比较复杂的需求：
我们定义了一个学生类，它的属性包括名字，性别，所在城市；

public class Student {

    private String name;
    private String sex;
    private String city;

    public Student(String name, String sex, String city) {
        this.name = name;
        this.sex = sex;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", sex='" + sex + ''' +
                ", city='" + city + ''' +
                '}';
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

然后我们定义一个集合存放学生类的对象

 List<Student> students = Arrays.asList(
                new Student("zhang", "男", "西安"),
                new Student("li", "男", "西安"),
                new Student("wang", "女", "北京"),
                new Student("zhao", "女", "上海"),
                new Student("zhou", "男", "北京")
        );

这时我们如果想要按照性别进行分组存储呢？（男生存在一起，女生存在一起）
按照我们本来的方法需要定义map数组，按照键值对形式，将性别和对象形成映射，然后存储起来；
具体代码：

Map<String, List<Student>> map2 = new HashMap<>();
        for (Student student : students) {
            if (student.getSex().equals("男")) {
                List<Student> nan = map2.get("男");
                if (nan == null) {
                    nan = new ArrayList<>();
                    map2.put("男", nan);
                }
                nan.add(student);
            } else {
                List<Student> nv = map2.get("女");
                if (nv == null) {
                    nv = new ArrayList<>();
                    map2.put("女", nv);
                }
                nv.add(student);
            }
        }
        System.out.println(map2);

我们发现上面的逻辑很复杂，我们也很容易出错，同时这只是我们按照性别分组，那如果类别特别多的话，比如我们按照所在城市分组呢？难道我们每一个都要进行判断吗？显然这是不现实的，这时我们就必须用Stream流来实现了：

//按照性别分组
Map<String, List<Student>> map3 = students.stream().collect(
Collectors.groupingBy( s -> s.getSex() ));
        System.out.println(map3);

这里我们用了groupingBy方法，传入的参数是一个Function,分组的标准就是我们function的返回属性；

//按照所在城市分组
Map<String, List<Student>> map4 = students.stream().collect(
Collectors.groupingBy( s -> s.getCity()));
        System.out.println(map4);

答案：
{
女=[Student{name=‘wang’, sex=‘女’, city=‘北京’}, Student{name=‘zhao’, sex=‘女’, city=‘上海’}],
男=[Student{name=‘zhang’, sex=‘男’, city=‘西安’}, Student{name=‘li’, sex=‘男’, city=‘西安’}, Student{name=‘zhou’, sex=‘男’, city=‘北京’}]
}

{
上海=[Student{name=‘zhao’, sex=‘女’, city=‘上海’}],
西安=[Student{name=‘zhang’, sex=‘男’, city=‘西安’}, Student{name=‘li’, sex=‘男’, city=‘西安’}],
北京=[Student{name=‘wang’, sex=‘女’, city=‘北京’}, Student{name=‘zhou’, sex=‘男’, city=‘北京’}]
}