一·什么是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);
    }
}
复制代码

结果：

结尾

我本人也是一个小白，自己平时练习着玩的，以后会继续补充的，希望可以帮到你们。