Passagem de expressão lambda combinada com algumas operações comumente usadas

        A expressão lambda é um novo recurso do JDK 8. Lambda pode substituir a maioria das classes internas anônimas e escrever um código Java melhor, especialmente na passagem de coleção e outras operações de coleção, que podem otimizar bastante a estrutura do código. Lambda consiste em lista de parâmetros, símbolo de seta -> e corpo da função.

        stream() não é uma estrutura de dados, é apenas uma visão de algum tipo de fonte de dados, a fonte de dados pode ser uma matriz, contêiner Java ou canal de E/S, etc. Nascido para programação funcional. Qualquer modificação no stream não modificará a fonte de dados por trás dele. Por exemplo, executar uma operação de filtro no stream não excluirá os elementos filtrados, mas gerará um novo stream que não contém os elementos filtrados. A operação no stream não será executada imediatamente, mas somente será executada quando o usuário realmente precisar do resultado. O fluxo só pode ser "consumido" uma vez e, uma vez percorrido, ficará inválido, assim como o iterador do contêiner, deve ser regenerado se quiser percorrê-lo novamente.

Agrupamento de coleções (obter Map<String, List<R>>)

redação em grupo

public static void main(String[] args) {
        // 构建实体对象 模拟从数据查到的数据 
        PersonEntity person1 = PersonEntity.builder().userId("1").userName("张三").userStatus("1").roomNumber("101").build();
        PersonEntity person_1 = PersonEntity.builder().userId("1").userName("张三").userStatus("-1").roomNumber("101").build();
        PersonEntity person2 = PersonEntity.builder().userId("2").userName("李四").userStatus("1").roomNumber("101").build();
        PersonEntity person3 = PersonEntity.builder().userId("3").userName("王五").userStatus("1").roomNumber("102").build();
        // personAllList添加实体 全部人员
        List<PersonEntity> personAllList = new ArrayList<>();
        personAllList.add(person1);
        personAllList.add(person2);
        personAllList.add(person3);
        Map<String, List<PersonEntity>> map = personAllList.stream().collect(Collectors.groupingBy(PersonEntity::getRoomNumber));
        System.out.println(map.toString());
    }

imprimir resultado

{101=[PersonEntity(userId=1, userName=张三, userStatus=1, roomNumber=101), PersonEntity(userId=2, userName=李四, userStatus=1, roomNumber=101)], 102=[PersonEntity(userId=3, userName=王五, userStatus=1, roomNumber=102)]}

Obtenha um elemento com o valor máximo do atributo de entidade na coleção

 // 获取id最大的用户
Optional<PersonEntity> personEntity= personAllList.stream().max(Comparator.comparing(PersonEntity::getUserId));

Obtenha o atributo de entidade na coleção e salve-o como um novo MAP(Map<String, String>)

Map<String, String> map = list.stream().collect(Collectors.toMap(vo::getxxx, vo::getxxx));

Exceção de chave xxxx duplicada

Quando usamos o Lambda para converter a lista em um mapa, aparecerá a exceção Duplicate key xxxx, o que significa que a chave a ser convertida em um mapa está duplicada. Além da desduplicação do loop for, temos outras maneiras de lidar com isso graciosamente isso.

1.key重复时直接用后面的值(使用最新的或最老的值)
Map<String, Long> collect = enterpriseWechatRelations.stream().collect(Collectors.toMap(EnterpriseWechatRelation::getExternalUserId, EnterpriseWechatRelation::getUserId,(val1, val2) -> val2));
2.将两个值拼接起来
Map<String, Long> collect = enterpriseWechatRelations.stream().collect(Collectors.toMap(EnterpriseWechatRelation::getExternalUserId,EnterpriseWechatRelation::getUserId,(val1, val2) -> val1+val2));

Obtenha uma nova entidade no atributo de entidade na combinação (List<BeanB>)

List<BeanB> newList = oldList.stream().map(e -> new BeanB(e.getId(), e.getName(), e.getAge())).collect(Collectors.toList());

A expressão classifica a idade em ordem positiva (classificada e invertida ())

// 正序
userInfoList = userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge)).collect(Collectors.toList());
// 逆序
userInfoList=userInfoList.stream().sorted(Comparator.comparing(UserInfo::getAge).reversed()) .collect(Collectors.toList());

filtrar em uma nova coleção com base em algum atributo

List<Category> categoryList = categoryService.selectCategoryList(category);
// 选出所有一级分类放入新的集合
List<Category> listLevel1=categoryList.stream().filter((Category c) ->"1".equals(c.getCategoryLevel())).collect(Collectors.toList());

//    获取设备类型为102的摄像头集合
List<AiDevice> cameraList=list.stream().filter((AiDevice b)- 
>"102".equals(b.getDeviceType())).distinct().collect(Collectors.toList());
// 然后根据摄像头对应的gatemateId 找到需要下发的盒子信息
List<AiDevice> result = cameraList.stream().collect(Collectors.collectingAndThen(
Collectors.toCollection(() -> new TreeSet<> 
(Comparator.comparing(AiDevice::getGatewayId))), ArrayList::new));

desduplicação por nome

List<ProdAPP> list =listOld.stream().collect(
        Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getProdName()))),ArrayList::new));

Conjuntos simples levam interseção, diferença, união, união de desduplicação

List<String> list1 = new ArrayList()；
List<String> list2 = new ArrayList();
// 交集
List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(Collectors.toList());
// 差集 (list2 - list1)
List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(Collectors.toList());
// 并集
List<String> listAll = list1.parallelStream().collect(Collectors.toList());
List<String> listAll2 = list2.parallelStream().collect(Collectors.toList());
listAll.addAll(listAll2);
// 去重并集
List<String> listAllDistinct = listAll.stream().distinct().collect(Collectors.toList());

Algumas somas e acumulações usam lambda

 // 汇总1：单列累加 
goodsInfoList.stream().map(GoodsInfoDTO::getPrice).reduce(BigDecimal.ZERO, BigDecimal::add);
// 汇总2：先过滤再单列累加（55.0）
goodsInfoList.stream().filter(goods ->         
"MATERIAL".equals(goods.getGoodsType())).map(GoodsInfoDTO::getPrice).reduce(BigDecimal.ZERO, BigDecimal::add);
// 汇总3：双列乘积并累加
goodsInfoList.stream().map(x -> x.getPrice().multiply(BigDecimal.valueOf(x.getQty()))).reduce(BigDecimal.ZERO, BigDecimal::add);
// 积汇4：双列乘积并累加
goodsInfoList.stream().reduce(BigDecimal.ZERO, (x, y) -> {
            return x.add(y.getPrice().multiply(BigDecimal.valueOf(y.getQty())));
        }, BigDecimal::add);
// 整形
 list.stream().mapToInt(a->a.getCount()).sum()
// double类型
list.stream().mapToDouble(a->a.getWeight()).sum();
// Long类型
list.stream().mapToLong(a -> a.getPri()).sum();
// BigDecimal类型
list.stream().map(Animal::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);