Map源码       

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

参数：传入一个Function函数式接口，类型分别是T、R
返回：Stream流，类型是R
作用：将T类型经过某种映射（由函数式接口抽象方法实现决定），变成R类型的Stream流

flatMap源码

参数：传入一个Function函数式接口，类型T、 Stream< R >
返回：Stream流，类型是R
作用：将T类型经过某种映射（由函数式接口抽象方法实现决定）(原本要转成 Stream< Stream< R > >)，变成R类型的Stream流

具体对比

   Stream<Object> objectStream = userList.stream().map(new Function<User, Object>() {
            @Override
            public Object apply(User user) {
                user.setPassword("");
                return user;
            }
        });

   Stream<Object> objectStream1 = userList.stream().flatMap(new Function<User, Stream<?>>() {
           @Override
            public Stream<?> apply(User user) {
                 user.setPassword("");
                 return Stream.of(user);
            }
        });

map函数式接口抽象方法的返回值是R，flatMap函数式接口抽象方法返回值是Stream< R >
所以flatMap作用就是将返回的Stream< R >拆开，再组合每个值成新的Stream< R >

       

   数据定义

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

        例子：map实例

List<Object> collect = userList.stream().map(new Function<User, Object>() {
       @Override
       public Object apply(User user) {
             user.setPassword("");
            return user;
        }
      }).collect(Collectors.toList());

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

        求两个集合的并集用flatmap

List<Object> collect11 = Stream.of(userList, userList1).flatMap(new Function<List<User>, Stream<?>>() {
            @Override
            public Stream<?> apply(List<User> users) {
                return users.stream();
            }
        }).collect(Collectors.toList());
        for (Object o : collect) {
            System.out.println(o);
}

//简写为
List<Object> collect1 = Stream.of(userList, userList1).flatMap(users -> users.stream()).collect(Collectors.toList());
collect1.forEach(System.out::println);

       集合的交集

 List<User> collect2 = userList.stream().filter(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return userList1.contains(user);
            }
        }).collect(Collectors.toList());

     集合的差集  就是去除集合都有的，如果以a表为主体，剩下就全是a的

 List<User> collect3 = userList.stream().filter(user -> !userList1.contains(user)).collect(Collectors.toList());