JAVASE学习笔记（十四）（stream流===＞ 结果映射 & 数据处理 &查找检索 ）

map & peek & flatmap（结果映射）

场景

• 场景： 把集合中每个用户对象的敏感信息进行赋值null，在进行返回。为什么呢？

在开发的时候，我们经常都是使用orm框架：mybatis, hibernate，或者写SQL写的 select * from这个时候数据返回过程中可能就会从存在敏感信息，这个时候开发者一定有意识，就是脱敏。 比如用户信息的密码因为要过滤才进行返回：

peek解决：

 List<User> userList = userList1.stream().peek(u -> u.setPassword("")).collect(Collectors.toList());
 userList.forEach(System.out::println);

map解决

List<User> userList2 = userList1.stream().map(u -> {
    u.setPassword("");
    return u;
}).collect(Collectors.toList());
userList2.forEach(System.out::println);

flatMap解决

List<Object> collect = userList1.stream().flatMap(user-> {
    user.setPassword("");
    return Stream.of(user);
}).collect(Collectors.toList());

collect.forEach(System.out::println);

flatMap与map区别

flatMap语法：

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

map语法

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

结论

查看源码发现，map是包括flatMap的
查看二者对该场景的解决方法可以看到：

• map返回的是一个具体的流化的对象（可以改变想返回的元素）
• flatMap返回的是一个stream流对象，可继续进行中间操作

那么flaMap在什么时候使用呢？

flatmap的使用

作用：合并、差集、交集、并集等操作非常的有用

• stream.of:返回一个流数组

1.合并-并集 & 返回指定列

package com.yue.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author: 夜雨
 * @Date: 2021-12-20-9:09
 * @Description:
 * @Version 1.0
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        //1.创建集合
        List<User> userList1 = new ArrayList<>();
        userList1.add(new User(1, "月色", 18, 1));
        userList1.add(new User(2, "夜雨", 16, 1));
        userList1.add(new User(3, "摇光", 18, 0));
        userList1.add(new User(4, "流苏", 19, 0));

        List<User> userList2 = new ArrayList<>();
        userList2.add(new User(5, "极光", 18, 1));
        userList2.add(new User(6, "北斗", 16, 1));
        userList2.add(new User(7, "紫薇", 18, 0));
        userList2.add(new User(8, "贪狼", 19, 0));

        //合并
        List<User> allUserList = Stream.of(userList1, userList2).flatMap(s -> s.stream()).collect(Collectors.toList());
        allUserList.forEach(System.out::println);

        System.out.println("++++++++++++++++");

        //合并   且   只输出姓名
        List<String> allUserList01 = Stream.of(userList1, userList2).flatMap(s -> s.stream().map(user -> {return user.getName();})).collect(Collectors.toList());
        System.out.println("allUserList01 = " + allUserList01);
    }

}

flatmap的场景一般来说多个集合操作的时候，它的价值就体现出来，一般如果单集合操作flatmap其实意义不大。

2. 合并-交集-共同好友

// 合并 -- 交集 -- 共同好友
List<User> allUserList2 = userList1.stream().filter(new Predicate<User>() {
    @Override
    public boolean test(User user) {
        return userList2.contains(user);
    }
}).collect(Collectors.toList());
allUserList2.forEach(System.out::println);

3. 合并-差集

 // 合并 -- 差集
List<User> allUserList3 = userList1.stream().filter(user -> !userList2.contains(user) ).collect(Collectors.toList());
   allUserList3.forEach(System.out::println);

reduce（数据处理）

概述

对数据进行运算处理，一般用于账单总计啥的。

语法

  T reduce(T identity, BinaryOperator<T> accumulator);

identity:起始位

案例

package com.kuangstudy.stream03;

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo04 {

    public static void main(String[] args) {


        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);

//        int intValue = list1.stream().reduce(1, new BinaryOperator<Integer>() {
//            @Override
//            public Integer apply(Integer integer, Integer integer2) {
//                return integer + integer2;
//            }
//        }).intValue();

        int intValue1 = list1.stream().reduce(1, (a, b) -> a + b).intValue();
        System.out.println(intValue1);
    }
}

其他的操作maptoInt、maptoDouble、maptoLong

可以用于聚合操作

public static void main(String[] args) {

	//账单
    List<ShopCart> shopCarts = new ArrayList<>();
    shopCarts.add(new ShopCart(1, "手机1", 1d, 1));//a
    shopCarts.add(new ShopCart(2, "手机2", 2d, 2));//b
    shopCarts.add(new ShopCart(3, "手机3", 3d, 3));

	//总和
    double doubleValue1 = shopCarts.stream().map(shopcart -> shopcart.getPrice() * shopcart.getNum()).reduce(0d, (a, b) -> a + b).doubleValue();
    //总和
    double doubleValue2 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice() * shopcart.getNum()).sum();
    //平均值
    double doubleValue3 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice()).average().getAsDouble();
    //最大值
    double doubleValue4 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice()).max().getAsDouble();
    //最小值
    double doubleValue5 = shopCarts.stream().mapToDouble(shopcart -> shopcart.getPrice()).min().getAsDouble();

    System.out.println(doubleValue1);
    System.out.println(doubleValue2);
    System.out.println(doubleValue3);
    System.out.println(doubleValue4);
    System.out.printn(doubleValue5);
}

查找检索

结束操作 anyMatch、noneMatch、allMatch

• anyMatch - anything: 任何，任意 只要有一个为true，就是true,否则就是false
• noneMatch: none :没有，无，没有一个满足条件就是true,否则就是false
• allMatch: all：全部，所有。所有满足条件才是true,否则就是false
• noneMatch 和 allMatch是相对立的

package com.kuangstudy.stream03;

import com.kuangstudy.stream.User;

import java.util.ArrayList;
import java.util.List;
import java.util.OptionalDouble;
import java.util.function.Predicate;

public class StreamDemo06 {

    public static void main(String[] args) {


        List<User> userList1 = new ArrayList<>();
        userList1.add(new User(1, "月色", 18, 1));
        userList1.add(new User(2, "夜雨", 16, 1));
        userList1.add(new User(3, "摇光", 18, 0));
        userList1.add(new User(4, "流苏", 19, 0));

//        User user = userList1.stream().findAny().get();
//        System.out.println(user);

//         anyMatch  只要集合中的某个元素满足条件就是true ,否则就是false
//        boolean anyMatch = userList1.stream().anyMatch(new Predicate<User>() {
//            @Override
//            public boolean test(User user) {
//                return user.getAge() > 16;
//            }
//        });

//      allMatch  和noneMatch是相对立的，必须条件全部满足才是true,否则false
//        boolean noneMatch = userList1.stream().allMatch(new Predicate<User>() {
//            @Override
//            public boolean test(User user) {
//                return user.getAge() > 16;
//            }
//        });
//        System.out.println(noneMatch);


        // noneMatch 相对于allMatch 必须条件全部不满足才是true,否则 false
        boolean noneMatch = userList1.stream().noneMatch(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getAge() > 16;
            }
        });

        System.out.println(noneMatch);
    }



}