java基础重难点总结之JDK新特性stream流

Stream两种操作

• 中间操作

  intermediate operation 中间操作：中间操作的结果是刻画、描述了一个Stream，并没有产生一个新集合，这种操作也叫做惰性求值方法。

  对应的方法如下：

  这是所有Stream中间操作的列表：
  过滤()==>filter()
  地图()==>map()
  转换()==>flatMap()
  不同()==>distinct() 
  排序()==>sorted()
  窥视()==>peek（）
  限制()==>limit()
  跳跃()==>skip()
  叠加()==>reduce()
  

• 终止操作

  terminal operation 终止操作：最终会从Stream中得到值。说白了：就是可以直接得到结果

  循环()==>foreach()
  总计()==>count()
  收集()==>collect()
  andMatch()
  noneMatch()
  allMatch()
  findAny()
  findFirst()
  min()
  max()
  

可以形象地理解Stream的操作是对一组粗糙的工艺品原型（即对应的 Stream 数据源）进行加工成颜色统一的工艺品（即最终得到的结果），第一步筛选出合适的原型（即对应Stream的 filter 的方法），第二步将这些筛选出来的原型工艺品上色（对应Stream的map方法），第三步取下这些上好色的工艺品（即对应Stream的 collect(toList())方法）。在取下工艺品之前进行的操作都是中间操作，可以有多个或者0个中间操作，但每个Stream数据源只能有一次终止操作，否则程序会报错。

filter的用法：

public class StreamDemo {

    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        userList.add(new User(1, "yykk", "111111", 34, 1, 34600d));
        userList.add(new User(2, "祈福", "2222222", 24, 0, 883600d));
        userList.add(new User(3, "小王", "3333333", 24, 1, 734090d));
        userList.add(new User(4, "小楠", "4444444", 14, 0, 33400d));
        userList.add(new User(5, "小张", "55555", 29, 1, 140000d));

        // 1： filter过滤
        List<User> collect = userList.stream().filter(res -> res.getSex()==1).collect(Collectors.toList());
        collect.forEach(System.out::println);

    }
}

map方法使用：

public class StreamDemo {

    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        userList.add(new User(1, "yykk", "111111", 34, 1, 34600d));
        userList.add(new User(2, "祈福", "2222222", 24, 0, 883600d));
        userList.add(new User(3, "小王", "3333333", 24, 1, 734090d));
        userList.add(new User(4, "小楠", "4444444", 14, 0, 33400d));
        userList.add(new User(5, "小张", "55555", 29, 1, 140000d));

        // 1： 使用map获取集合中username列
        List<String> userNameList = userList.stream().map(res -> res.getUsername()).collect(Collectors.toList());
        userNameList.forEach(System.out::println);

        // 2: 使用map获取集合中的id,username,age,sex,shenjia，排除password
        List<Map<String, Object>> collect = userList.stream().map(user -> {
            Map<String, Object> map = new HashMap<>();
            map.put("id",user.getId());
            map.put("age",user.getAge());
            map.put("sex",user.getSex());
            map.put("shenjia",user.getShenjia());
            return map;
        }).collect(Collectors.toList());
        collect.forEach(System.out::println);
        
        /*
         // 4: 使用map + min/max/count/sum快速求所有用户
        List<Map<String, Object>> mapList = userList.stream().map(new Function<User, Map<String, Object>>() {
            @Override
            public Map<String, Object> apply(User user) {
                Map<String, Object> map = new HashMap<>();
                map.put("id", user.getId());
                map.put("age", user.getAge());
                map.put("sex", user.getSex());
                map.put("shenjia", user.getShenjia());
                return map;
            }
        }).collect(Collectors.toList());
        mapList.forEach(System.out::println);
        */
        

        // 3: 快速清空password
        List<User> userList1 = userList.stream().map(user -> {
            user.setPassword("");
            return user;
        }).collect(Collectors.toList());
        userList1.forEach(System.out::println);

        // 4: 使用map + min/max/count/sum快速求所有用户
        Integer maxage = userList.stream().map(user -> user.getAge()).max((a,b)->a-b).get();
        Integer minage = userList.stream().map(user -> user.getAge()).min((a,b)->a-b).get();
        long count = userList.stream().map(user -> user.getAge()).count();
        long sumcount1 = userList.stream().map(user -> user.getAge()).reduce((a,b)->a+b).get();
        long sumcount2 = userList.stream().mapToInt(user -> user.getAge()).sum();
        System.out.println(maxage);
        System.out.println(minage);
        System.out.println(count);
        System.out.println(sumcount1);
        System.out.println(sumcount2);
        System.out.println(sumcount1/count);
    }
}

flatMap方法-中间操作-过滤

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

这个接口，跟map一样，接收一个Fucntion的函数式接口，不同的是，Function接收的泛型参数，第二个参数是一个Stream流；方法，返回的也是泛型R，具体的作用是把两个流，变成一个流返回，下面，我们看一个案例，来详细解答，怎么把两个流的内容，变成一个流的内容

public class StreamDemo2 {

    public static void main(String[] args) {
        List<User> userList = new ArrayList<>();
        userList.add(new User(1, "yykk", "111111", 34, 1, 34600d));
        userList.add(new User(2, "祈福", "2222222", 24, 0, 883600d));
        userList.add(new User(3, "小王", "3333333", 24, 1, 734090d));
        userList.add(new User(4, "小楠", "4444444", 14, 0, 33400d));
        userList.add(new User(5, "小张", "55555", 29, 1, 140000d));

        List<User> userList2 = new ArrayList<>();
        userList2.add(new User(1, "yykk", "111111", 34, 1, 34600d));
        userList2.add(new User(7, "祈福", "2222222", 24, 0, 883600d));
        userList2.add(new User(8, "小王", "3333333", 24, 1, 734090d));
        userList2.add(new User(9, "小楠", "4444444", 14, 0, 33400d));
        userList2.add(new User(10, "小张", "55555", 29, 1, 140000d));


        //flatmap一般用于：
        // 使用Java8实现集合的并、交、差操作
        // 具体的作用是把两个流，变成一个流返回

        //案例一：合并两个集合
        System.out.println("============案例一 合并==============");
        List<User> collect = userList.stream().flatMap(user->userList2.stream()).collect(Collectors.toList());
        collect.forEach(System.out::println);

        System.out.println("============案例二取交集==============");
        // 案例二取交集
        List<User> userList1 = userList.stream().filter(userList2::contains).collect(Collectors.toList());
        userList1.forEach(System.out::println);

        System.out.println("===========案例三取并集===============");
        // 案例三取并集
        List<User> userList3= Stream.of(userList,userList2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
        userList3.forEach(System.out::println);

        System.out.println("=========== 案例四取差集===============");
        // 案例四 取差集
        List<User> userList4= userList.stream().filter(user -> !userList2.contains(user)).collect(Collectors.toList());
        userList4.forEach(System.out::println);

        int sum = Stream.of(userList,userList2).flatMapToInt(user -> user.stream().mapToInt(u->u.getAge())).sum();
        System.out.println(sum);

    }
}