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

解释。。。我收到两个类型为

MyDTO

的列表的返回，并将这两个返回添加到一个列表中。在前两次返回中，这些记录被标记为

Enum

。 由于名单来自不同的地方，我可以重复记录。 而且，如果有重复记录，我必须在

Enum

中用特定类型标记它，并且只留下一条记录

多年电价目标：

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

我的回程舱：

@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
    }
}

那么，如何检查该项是否重复（在两个列表中都返回），并使用

Enum

3的类型对其进行标记？

List first=firstReturnMyDTO（）；
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);

List second=secondReturnMyDTO（）；
ListmyDTOList=newarraylist（第一）；
Set uniqueSet=new HashSet（）；
//从myDTOList中删除第二个列表中不存在的人
myDTOList.retainal（第二）；
//从myDTOList中首先移除那些存在于myDTOList中的人
第一，removeAll（myDTOList）；
//从第二个列表中删除myDTOList中的成员
第二，removeAll（myDTOList）；
//获取唯一的值
第一，addAll（第二）；
//处理重复项-存储在myDTOList中
//将它们添加到集合将删除重复项。
//然后，用枚举3标记它们
uniqueSet.addAll（myDTOList）；
用于（MyDTO m:uniqueSet）
m、 myEnum=myEnum.two返回值
//将unique添加到集合中
uniqueSet.addAll（第一）；
//如果需要，请转换为列表
列表非重复列表=新的ArrayList（uniqueSet）；

现在，非重复列表只包含非重复条目。

List first=firstReturnMyDTO（）；
List second=secondReturnMyDTO（）；
ListmyDTOList=newarraylist（第一）；
Set uniqueSet=new HashSet（）；
//从myDTOList中删除第二个列表中不存在的人
myDTOList.retainal（第二）；
//从myDTOList中首先移除那些存在于myDTOList中的人
第一，removeAll（myDTOList）；
//从第二个列表中删除myDTOList中的成员
第二，removeAll（myDTOList）；
//获取唯一的值
第一，addAll（第二）；
//处理重复项-存储在myDTOList中
//将它们添加到集合将删除重复项。
//然后，用枚举3标记它们
uniqueSet.addAll（myDTOList）；
用于（MyDTO m:uniqueSet）
m、 myEnum=myEnum.two返回值
//将unique添加到集合中
uniqueSet.addAll（第一）；
//如果需要，请转换为列表
列表非重复列表=新的ArrayList（uniqueSet）；

现在，非重复列表只包含非重复条目。

类似的内容

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;
                }
            }
            
        }

for（int i=0；i
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;
                }
            }
            
        }

for（int i=0；i对于使用Java Stream的（int j=i+1；j，可以使用表示
someField
和
codMyDto
的键构建映射，并将枚举收集到集合中。之后，映射的条目将根据集合的大小/内容重新映射到
MyDto

受保护列表myMainMethod（）引发异常{
return Stream.concat（firstReturnMyDTO（）.Stream（），secondReturnMyDTO（）.Stream（））
.collect（收集器.groupingBy(
dto->Arrays.asList（dto.getSomeField（），dto.getCodMyDto（），//键w/o枚举
Collectors.mapping（MyDto:：getMyEnum，Collectors.toSet（））
))//列表键的映射，设置
.entrySet（）.stream（）
.map（e->新MyDto(
e、 getKey（）.get（0），//key中的某个字段
e、 getValue（）.size（）>1？MyEnum.TWORETURNS
：e.getValue（）.contains（MyEnum.MYSECONDTYPE）？MyEnum.MYSECONDTYPE
：MyEnum.MYFIRSTTYPE，
e、 getKey（）.get（1）//mycodto-from-key
))
.collect（Collectors.toList（））；
}

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

受保护列表myMainMethod（）引发异常{
return Stream.concat（firstReturnMyDTO（）.Stream（），secondReturnMyDTO（）.Stream（））
.collect（收集器.groupingBy(
dto->new MyDto（dto.getSomeField（），null，dto.getCodMyDto（）），//键w/o枚举
Collectors.mapping（MyDto:：getMyEnum，Collectors.toSet（））
))//MyDto键的映射，myEnum为null，Set
.entrySet（）.stream（）
.map（e->新MyDto(
e、 getKey（）.getSomeField（），//key中的someField
e、 getValue（）.size（）>1？MyEnum.TWORETURNS
：e.getValue（）.contains（MyEnum.MYSECONDTYPE）？MyEnum.MYSECONDTYPE
：MyEnum.MYFIRSTTYPE，
e、 getKey（）.getCodMyDto（）//MyCodTo from key
))
.collect（Collectors.toList（））；
}
使用Java Stream，可以使用表示
someField
和
codMyDto
的键构建映射，并将枚举收集到集合中。之后，映射的条目将根据集合的大小/内容重新映射到
MyDto

受保护列表myMainMethod（）引发异常{
return Stream.concat（firstReturnMyDTO（）.Stream（），secondReturnMyDTO（）.Stream（））
.collect（收集器.groupingBy(
dto->Arrays.asList（dto.getSomeField（），dto.getCodMyDto（），//键w/o枚举
Collectors.mapping（MyDto:：getMyEnum，Collectors.toSet（））
))//列表键的映射，设置
.entrySet（）.stream（）
.map（e->新MyDto(
e、 getKey（）.get（0），//key中的某个字段
e、 getValue（）.size（）>1？MyEnum.TWORETURNS
：e.getValue（）.contains（MyEnum.MYSECONDTYPE）？MyEnum.MYSECONDTYPE
：MyEnum.MYFIRSTTYPE，
e、 getKey（）.get（1）//mycodto-from-key
))
.collect（Collectors.toList（））；
}

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

受保护列表myMainMethod（）引发异常{
return Stream.concat（firstReturnMyDTO（）.Stream（），secondReturnMyDTO（）.Stream（））