一·什么是stream

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。Stream主要用于取代部分Collection的操作， 每个流代表一个值序列，流提供一系列常用的聚集操作 ，可以便捷的在它上面进行各种运算。

二·stream的特点

①只能遍历一次：

数据流的从一头获取数据源，在流水线上依次对元素进行操作，当元素通过流水线，便无法再对其进行操作，可以重新在数据源获取一个新的数据流进行操作；

②采用内部迭代的方式：

对Collection进行处理，一般会使用 Iterator 遍历器的遍历方式，这是一种外部迭代；

而对于处理Stream，只要申明处理方式，处理过程由流对象自行完成，这是一种内部迭代，对于大量数据的迭代处理中，内部迭代比外部迭代要更加高效；

三·详细用法

1) 计算元素总数count

    ArrayList<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    long count = list.stream().count(); //返回是一个long类型
    System.out.println(count); //count=3
    复制代码

2) 去重 distinct

    //去除列表中的重复元素
    List<String> list = Arrays.asList("a", "b", "b", "c");
    List<String> distinct = list.stream()
            .distinct()
            .collect(Collectors.toList());
    System.out.println(distinct); //[a, b, c]
    复制代码

3) 筛选filter

    //筛选出列表中的非空项
    List<String> list = Arrays.asList("a", "b", "", "c");
    List<String> filter = list.stream()
            .filter(s -> !s.isEmpty())
            .collect(Collectors.toList());
    System.out.println(filter);//[a, b, c]
    复制代码

4) 截取 limit

    //获取list的前3个值
            List<String> list = Arrays.asList("a", "b", "c", "d");
            List<String> limit = list.stream()
                    .limit(3)
                    .collect(Collectors.toList());
            System.out.println(limit);//[a, b, c]
    复制代码

5) 跳过 skip

    //跳过list的前两个值获取后面的值
    List<String> list = Arrays.asList("a", "b", "c", "d");
    List<String> skip = list.stream()
            .skip(2)
            .collect(Collectors.toList());
    System.out.println(skip);//[c, d]
    复制代码

6) 映射 map （常用）

    //将集合中的每一个元素转为字符串
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
            List<String> result = list.stream()
                    .map(x -> String.valueOf(x))
                    .collect(Collectors.toList()); 
            System.out.println(result);//[1, 2, 3, 4, 5]
    复制代码

    //        将字符串全部变成大写
            List<String> list = new ArrayList<>();
            list.add("zhangwuji");
            list.add("zhaomin");
            list.add("zhouzhiruo");
            List<String> collect = list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());
            System.out.println(collect);//[ZHANGWUJI, ZHAOMIN, ZHOUZHIRUO]
    复制代码

7) 遍历 foreach（常用）

    //使用stream流进行遍历
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    list.stream().forEach(name-> System.out.println(name)); 
    复制代码

8）排序 sorted

sorted方法用来流排序，默认升序排布，可以使用一个 Comparator 作为参数来实现自定义排序.

            //正序
            List<String> list = Arrays.asList("aa", "ff", "dd");
    //String 类自身已实现Compareable接口 
            list.stream().sorted().forEach(System.out::println);// aa dd ff
    复制代码

            //倒序
        public static Comparator<String> getComparator(){
            //方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
    //        return new Comparator<String>() {
    //            @Override
    //            public int compare(String o1, String o2) {
    //                //按照字符串的降序排序
    //                return o2.length()-o1.length();
    //            }
    //        };
    
            //方法的返回值类型是一个函数式接口，所以可以返回一个lambda表达式
            return (o1, o2) -> o2.length()-o1.length();
        }
    
        public static void main(String[] args) {
            String[] arr = {"aaa","b","ccccc","dddddddddddd"};
            System.out.println(Arrays.toString(arr));//[aaa, b, ccccc, dddddddddddd]排序前
            Arrays.sort(arr,getComparator());
            System.out.println(Arrays.toString(arr));//[dddddddddddd, ccccc, aaa, b]排序后
        }
    复制代码

    public static void main(String[] args) {
    //自定义map的排序 根据
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("name", "p");
        map1.put("cj", "5");
        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("name", "h");
        map2.put("cj", "12");
        Map<String, Object> map3 = new HashMap<String, Object>();
        map3.put("name", "f");
        map3.put("cj", "31");
        list.add(map1);
        list.add(map3);
        list.add(map2);
        //排序前
        for (Map<String, Object> map : list) {
            System.out.println(map.get("cj"));
        }
        Collections.sort(list, (o1, o2) -> {
            Integer name1 = Integer.valueOf(o1.get("cj").toString()) ;//name1是从你list里面拿出来的一个
            Integer name2 = Integer.valueOf(o2.get("cj").toString()) ; //name1是从你list里面拿出来的第二个name
            return name2.compareTo(name1);
        });
        //排序后
        System.out.println("-------------------");
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
    }
    复制代码

结果：