如何从列表中删除重复记录并用枚举标记它？

Question

正在解释...我收到了两个 MyDTO 类型列表的 return 并将这两个 return 添加到一个列表中。这些记录在前两个 return 中被标记为 Enum。由于名单来自不同的地方，我可以有重复的记录。而且，如果有重复的记录，我必须在Enum中用具体的类型标记出来，只留一条记录。

MyDTO:

@Builder
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(exclude = {"myEnum","someField"})
@Getter
@Setter
@ToString
public class MyDTO {
    private String someField;
    private MyEnum myEnum;
    private Long codMyDto;
}

我的returnclass:

@Slf4j
@Singleton
@RequiredArgsConstructor
public class MyCreateContextClass {

    @Override
    protected List<MyDTO> myMainMethod() throws Exception {
        List< MyDTO > myDTOList = new ArrayList<>();

        myDTOList.addAll(firstReturnMyDTO());
        myDTOList.addAll(secondReturnMyDTO());

        // Mark the repeated items with type 3 of the Enum and make them unique.
       // How to do that ?

        return myDTOList; // My return must have unique items with correct enum
    }

    private List<MyDTO> firstReturnMyDTO() throws Exception {    
        return returnFirstListFromDTO.returnDTO(); // here my Enum is 1
    }

    private List<MyDTO> secondReturnMyDTO() throws Exception {
        return returnSecondListFromDTO.returnDTO(); // here my Enum is 2
    }
}

我的枚举：

@Getter
public enum MyEnum {

    MYFIRSTYTPE(1, “first”), // first addAll
    MYSECONDTYPE(2, “second”), // second addAll
    TWORETURNS(3, “all”); // in case the item is on both lists.

    private Integer key;
    private String value;

    MyEnum(Integer key, String value) {
        this.key = key;
        this.value = value;
    }

    public static MyEnum getEnum(Integer key) {
        for (MyEnum myEnum : MyEnum.values()) {
            if (myEnum.getKey().equals(key)) {
                return myEnum;
            }
        }
        return MyEnum.MYFIRSTYTPE;
    }
}

那么，我如何检查该项目是否重复（return在两个列表中）并将其标记为 Enum 3 的类型？

Answer 1

List<MyDTO> first = firstReturnMyDTO();
List<MyDTO> second = secondReturnMyDTO();
List< MyDTO > myDTOList = new ArrayList<>(first);
Set<MyDTO> uniqueSet = new HashSet<>();  

//remove from myDTOList those who are not present in second
myDTOList.retainAll(second);
//remove from first those who are present in myDTOList
first.removeAll(myDTOList);
//remove from second those who are present in myDTOList
second.removeAll(myDTOList);

//get the unique values
first.addAll(second); 

//handle the duplicates - stored in myDTOList
//adding them to the set will remove the duplicates. 
//Then, mark them with enum 3
 uniqueSet.addAll(myDTOList);
 for (MyDTO m : uniqueSet)
     m.myEnum = MyEnum.TWORETURNS
//add the uniques to the set
uniqueSet.addAll(first);

//if wanted, convert to list
List<MyDTO> nonDuplicateList = new ArrayList<>(uniqueSet);

现在 nonDuplicateList 只包含非重复条目。

Answer 2

是这样的吗？

for(int i = 0; i< list.size(); i++) {
            for(int j = i+1; j<list.size(); j++) {
                if(list.get(i).equals(list.get(j))) {
                    list.get(i).myEnum = MyEnum.TWORETURNS;
                    list.remove(j);
                    break;
                }
            }
            
        }

覆盖 MyDTO 中的 'equals' 方法或添加特定比较。

Answer 3

使用 Java 流，可以使用表示 someField 和 codMyDto 的键构建映射，并将枚举收集到集合中。之后，映射的条目根据集合的 size/contents 重新映射到 MyDto。

protected List<MyDTO> myMainMethod() throws Exception {
    return Stream.concat(firstReturnMyDTO().stream(), secondReturnMyDTO().stream())
            .collect(Collectors.groupingBy(
                dto -> Arrays.asList(dto.getSomeField(), dto.getCodMyDto()), // key w/o enum
                Collectors.mapping(MyDto::getMyEnum, Collectors.toSet())
            )) // map of List<?> key, Set<MyEnum>
            .entrySet().stream()
            .map(e -> new MyDto(
                e.getKey().get(0), // someField from key
                e.getValue().size() > 1 ? MyEnum.TWORETURNS 
                    : e.getValue().contains(MyEnum.MYSECONDTYPE) ? MyEnum.MYSECONDTYPE
                    : MyEnum.MYFIRSTTYPE,
                e.getKey().get(1) // myCodDto from key 
            ))
            .collect(Collectors.toList());
    }

可以使用 MyDto 作为键而不是原始列表：

protected List<MyDTO> myMainMethod() throws Exception {
    return Stream.concat(firstReturnMyDTO().stream(), secondReturnMyDTO().stream())
            .collect(Collectors.groupingBy(
                dto -> new MyDto(dto.getSomeField(), null, dto.getCodMyDto()), // key w/o enum
                Collectors.mapping(MyDto::getMyEnum, Collectors.toSet())
            )) // map of MyDto key with null myEnum, Set<MyEnum>
            .entrySet().stream()
            .map(e -> new MyDto(
                e.getKey().getSomeField(), // someField from key
                e.getValue().size() > 1 ? MyEnum.TWORETURNS 
                    : e.getValue().contains(MyEnum.MYSECONDTYPE) ? MyEnum.MYSECONDTYPE
                    : MyEnum.MYFIRSTTYPE,
                e.getKey().getCodMyDto() // myCodDto from key 
            ))
            .collect(Collectors.toList());
    }

如何从列表中删除重复记录并用枚举标记它？

How can I remove a duplicate record from the list and mark it with an enum?

java

java-11

micronaut