从集合类到Lambda表达式

集合类常用方法与lambda表达式分阶段使用

集合类操作

list遍历删除1：循环删除

在List的foreach循环中删除当前对象是不可行的，因为foreach循环是基于枚举器（enumerator）的，并且不允许修改正在枚举的集合。如果在循环中尝试删除当前对象，会引发一个InvalidOperationException异常。

如果我们想要从List中删除特定的对象，可以考虑使用for循环或while循环来遍历列表，并使用List的Remove方法来删除对象。

下面是一个使用for循环来删除对象的示例代码：

List<T> list = new List<T>(); // 假设列表是T类型的

for (int i = list.size() - 1; i >= 0; i--)
{
    if (//判断条件)
    {
        list.remove(i);
    }
}

在这个示例中，我们使用for循环从后向前遍历列表，并使用RemoveAt方法删除满足条件的对象。

请注意，删除对象可能会影响循环的索引，因此我们从后向前遍历以避免出现索引越界的问题。另外，我们需要将if语句中的//判断条件替换为我们自己的删除条件。

list遍历删除2：removeIf方法

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 创建一个包含一些整数的列表
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));

        // 使用removeIf方法删除所有的偶数
        list.removeIf(n -> n % 2 == 0);

        // 打印修改后的列表
        System.out.println(list);  // 输出: [1, 3, 5]
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个包含Person对象的列表
        List<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 20));
        list.add(new Person("Bob", 30));
        list.add(new Person("Charlie", 40));

        // 使用removeIf方法删除所有名字长度大于4且年龄大于25的Person对象
        list.removeIf(p -> p.name.length() > 4 && p.age > 25);

        // 打印修改后的列表
        for (Person p : list) { 
            System.out.println(p);
        }
    }
}

pwrSystemList.removeIf(a -> a.getPwrSystemId().equals(pwrSystem.getOwnSystemId()));

List根据对象属性去重

List<MeetUserList> parseOriginMeetUserList = JSON.parseArray(originMeetUserList, MeetUserList.class);
List<MeetUserList> distParseOriginMeetUserList = parseOriginMeetUserList.stream()
        .collect(Collectors.groupingBy(MeetUserList::getUser))
        .values().stream()
        .map(list -> list.get(0))
        .collect(Collectors.toList());

提取对象数组的多个属性为一个List

List<String> deviceSpecAndNameList = deviceList.stream().map(device -> device.getResSpecId() + ":" + device.getName()).collect(Collectors.toList());

foreach->lambda

将一个列表中的对象，进行某些操作，转移到另一个列表中：

foreach中new对象

foreach版本：

List<BsUnitIndicatorVo> bsUnitIndicatorVos = new ArrayList<>();
for(BsUnitVo bsUnitVo : bsUnitVos){
    BsUnitIndicatorVo bsUnitIndicatorVo = new BsUnitIndicatorVo();
    bsUnitIndicatorVo.setNum(0);
    bsUnitIndicatorVo.setUnitName(bsUnitVo.getInternalName());
    bsUnitIndicatorVo.setUnitCode(bsUnitVo.getUnitCode());
    bsUnitIndicatorVos.add(bsUnitIndicatorVo);
}

真·foreach(lambda中的foreach方法)

labmda表达式简化1：

List<BsUnitIndicatorVo> bsUnitIndicatorVos = new ArrayList<>();
bsUnitVos.foreEach(bsUnitVo -> {
    BsUnitIndicatorVo bsUnitIndicatorVo = new BsUnitIndicatorVo();
    bsUnitIndicatorVo.setNum(bsUnitVo.getNum());
    bsUnitIndicatorVo.setUnitName(bsUnitVo.getInternalName());
    bsUnitIndicatorVo.setUnitCode(bsUnitVo.getUnitCode());
    bsUnitIndicatorVos.add(bsUnitIndicatorVo);
})

一箭双雕版本

lambda表达式再次简化：

List<BsUnitIndicatorVo> bsUnitIndicatorVos = bsUnitVos.stream()
    .map(m -> {
        BsUnitIndicatorVo bsUnitIndicatorVo = new BsUnitIndicatorVo();
        bsUnitIndicatorVo.setNum(0);
        bsUnitIndicatorVo.setUnitName(m.getInternalName());
        bsUnitIndicatorVo.setUnitCode(m.getUnitCode());
        return bsUnitIndicatorVo;
    }).collect(Collectors.toList());

一键提取List中某个属性为新List

List<Order> orderList = new ArrayList<>();
Order order1 = new Order(1L, "order-001");
Order order2 = new Order(2L, "order-002");
orderList.add(order1);
orderList.add(order2);

List<Long> orderIdList = orderList.stream().map(Order::getId).collect(Collectors.toList());

QueryWrapper<Order> wrapper = new QueryWrapper<>();
wrapper.in("order_id", orderIdList);