<think>嗯，用户问的是在
Java中如何获取
List对象去重后的
多个字段。我需要先理解他们的需求。他们可能有
一个包含
多个对象的
List，每个
对象有若干
字段，他们希望根据其中几个
字段的组合来去重，保留这些
字段唯一的
对象。
首先，我得考虑
Java中常用的去重方法。如果是单个
字段，可能用Stream的distinct()就行，但
多个字段的话，distinct()可能不够，因为
对象默认比较的是
对象引用而不是
字段值。这时候可能需要重写
对象的equals和hashCode方法，但用户可能不想修改原有
对象的代码，或者需要动态指定
多个字段。
另
一个方法是使用Stream的filter配合
一个Set来记录已经出现过的
字段组合。比如，使用TreeSet或者HashSet，将每个
对象的关键
字段组合
成唯一标识符，比如字符串或者自定义的键
对象，然后检查是否已经存在于Set中，不存在的话就保留，并添加到Set里。
或者，可以考虑使用
Java 8的Collectors.toCollection，结合
一个自定义的收集器，确保元素根据
多个字段去重。比如，使用Collectors.collectingAndThen，里面用到
一个LinkedHashSet来保持顺序，同时去重。这时候需要提供
一个自定义的Predicate或者Function来生
成唯一键。
还有可能用户希望保持原
List的顺序，所以用LinkedHashSet比较好，因为HashSet不保证顺序，而TreeSet会排序。但用户可能更关心的是如何提取
多个字段的组合作为唯一标识，而不仅仅是整个
对象的去重。
比如，假设有
一个Person类，有name和age
字段，用户想根据这
两个字段去重。这时候，可以遍历
List，将每个
对象的name和age提取出来，组合
成键，比如用字符串"name,age"，或者用
一个自定义的Pair类。然后利用Set的特性，检查是否已经存在这样的键，从而过滤掉重复项。
具体实现的话，可以使用Stream API的filter操作，维护
一个并发的Set来记录已经处理过的键。例如：
list.stream()
.filter(person
-> ConcurrentHashMap.newKeySet().add(person.getName() + "#" + person.getAge()))
.collect(Collectors.to
List());
不过，这种方法在并行流中可能有问题，因为ConcurrentHashMap的newKeySet()可能无法正确同步。或者可以使用
一个HashSet，并配合synchronized块，但这样会影响性能。或者更好的办法是使用
一个中间容器，比如用TreeSet并自定义Comparator，根据
多个字段进行比较，然后通过TreeSet来去重，最后将Set转换回
List。
例如：
List<Person> distinct
List =
list.stream()
.collect(Collectors.collectingAndThen(
Collectors.toCollection(()
-> new TreeSet<>(Comparator.comparing(p
-> p.getName() + p.getAge()))),
Array
List::new
));
不过这里要注意，如果直接
拼接字符串可能会有问题，比如不同
字段组合可能产生相同的字符串，比如name="ab", age="c"和name="a", age="bc"会
拼接成"abc"，导致错误去重。所以更好的办法是使用
多个字段的比较器链，比如Comparator.comparing(Person::getName).thenComparingInt(Person::getAge)，这样TreeSet会根据这
两个字段的自然顺序来去重。
所以正确的做法应该是：
Set<Person> seen = new TreeSet<>(Comparator.comparing(Person::getName).thenComparingInt(Person::getAge));
List<Person> distinct =
list.stream()
.filter(p
-> seen.add(p))
.collect(Collectors.to
List());
不过这里有个问题，因为TreeSet的add方法会返回boolean，表示是否添加
成功。但如果在并行流中使用，会有线程安全问题，因为HashSet或TreeSet都不是线程安全的。所以应该使用线程安全的Set，比如ConcurrentHashMap的keySet，或者同步机制。
另一种方法是使用Stream的distinct()方法，但需要根据
多个字段生
成一个包装
对象，比如将需要去重的
字段封装到
一个内部类或记录中，然后根据这个包装类进行去重。例如：
list.stream()
.map(p
-> new AbstractMap.SimpleEntry<>(p.getName(), p.getAge()))
.distinct()
.map(entry
-> new Person(entry.getKey(), entry.getValue()))
.collect(Collectors.to
List());
不过这种方法需要创建中间
对象，可能会影响性能，特别是数据量大时。或者如果使用
Java 16+，可以使用record来简化：
record PersonKey(String name, int age) {}
List<Person> distinct =
list.stream()
.map(p
-> new PersonKey(p.getName(), p.getAge()))
.distinct()
.map(key
-> new Person(key.name(), key.age()))
.collect(Collectors.to
List());
但这样可能需要将原始
对象转换为新的键
对象，再转换回来，如果原
对象有其他
字段需要保留的话，这可能不适用，因为用户可能希望保留原
对象，而不仅仅是根据某些
字段去重后的新实例。
所以可能需要保留原
对象，但根据
多个字段去重。这时候，可以使用自定义的distinct方法，例如使用filter和ConcurrentHashMap：
Set<String> seen = ConcurrentHashMap.newKeySet();
List<Person> distinct =
list.stream()
.filter(p
-> seen.add(p.getName() + ";" + p.getAge()))
.collect(Collectors.to
List());
但同样需要注意
字段拼接后的唯一性，确保不同的
字段组合不会产生相同的字符串。比如用分隔符来分隔不同
字段，避免上述问题。
总结下来，用户可能需要根据
多个字段组合去重，同时保留原
对象。可能的解决方案有：
1. 使用TreeSet和自定义Comparator，在收集时去重。
2. 使用Stream的filter和并发的Set来维护已出现的键。
3. 使用
Java的record或临时
对象配合distinct()方法。
需要根据具体情况选择，比如是否需要保持顺序、线程安全、性能考虑等。此外，还要注意
字段拼接可能带来的潜在问题，使用合适的分隔符或者比较方式。
最后，给出示例代码，说明不同的实现方式，并提醒用户注意线程安全和
字段拼接的问题。</think>在
Java 中，对 `
List`
对象根据
多个字段进行去重，可以通过以下方法实现：
---
### **方法一：使用 `Stream` + 自定义 `Comparator`**
通过 `TreeSet` 的**自定义比较器**实现多
字段去重，保留第
一个出现的
对象：
```
java
import
java.util.*;
import
java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Person>
list = Arrays.as
List(
new Person("Alice", 25, "NY"),
new Person("Bob", 30, "LA"),
new Person("Alice", 25, "SF") // 重复的 name 和 age
);
// 根据 name 和 age 去重
List<Person> distinct
List =
list.stream()
.collect(Collectors.collectingAndThen(
Collectors.toCollection(()
->
new TreeSet<>(Comparator
.comparing(Person::getName)
.thenComparingInt(Person::getAge)
)
), Array
List::new
));
distinct
List.forEach(System.out::println);
}
}
class Person {
private String name;
private int age;
private String city;
// 构造方法、Getter、Setter 和 toString 略
}
```
---
### **方法二：使用 `Stream` + 动态唯一键**
通过 `filter` 和 `ConcurrentHashMap` 维护已出现的
字段组合键：
```
java
import
java.util.*;
import
java.util.concurrent.ConcurrentHashMap;
import
java.util.function.Function;
import
java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Person>
list = Arrays.as
List(
new Person("Alice", 25, "NY"),
new Person("Bob", 30, "LA"),
new Person("Alice", 25, "SF") // 重复的 name 和 age
);
// 根据 name 和 age 生
成唯一键
Set<String> seenKeys = ConcurrentHashMap.newKeySet();
List<Person> distinct
List =
list.stream()
.filter(p
-> seenKeys.add(p.getName() + "|" + p.getAge()))
.collect(Collectors.to
List());
distinct
List.forEach(System.out::println);
}
}
```
---
### **方法三：使用 `record` 辅助类（
Java 16+）**
通过 `record` 定义临时键，利用 `distinct()` 去重：
```
java
import
java.util.*;
import
java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Person>
list = Arrays.as
List(
new Person("Alice", 25, "NY"),
new Person("Bob", 30, "LA"),
new Person("Alice", 25, "SF")
);
// 定义临时记录类作为键
record PersonKey(String name, int age) {}
List<Person> distinct
List =
list.stream()
.map(p
-> new PersonKey(p.getName(), p.getAge()))
.distinct()
.map(key
->
list.stream()
.filter(p
-> p.getName().equals(key.name()) && p.getAge() == key.age())
.findFirst()
.orElse(null)
)
.filter(Objects::nonNull)
.collect(Collectors.to
List());
distinct
List.forEach(System.out::println);
}
}
```
---
### **注意事项**
1. **
字段分隔符**：使用唯一分隔符（如 `|`）避免
拼接字段时意外冲突。
2. **保留第
一个元素**：上述方法默认保留首次出现的
对象，若需自定义规则（如保留最后
一个），需调整过滤逻辑。
3. **性能**：大数据量时优先使用方法二（基于 `ConcurrentHashMap`），避免 `TreeSet` 的排序开销。
根据需求选择合适的方法即可实现多
字段去重。
本文介绍如何使用 Java 的 Stream API 对数据进行高效拼接，并通过过滤操作去除空值和 null 值，确保数据的准确性。演示了从用户列表中提取特定字段并进行处理的全过程。
扫一扫
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
