###
对象数组去重的
实现方法
在编程中，
对象数组的
去重操作可以通过多种方式
实现。以下是几种常见的解决方案及其代码示例。
#### 1. 使用 `Set` 和自定义比较逻辑
由于 `Set` 无法直接对
对象数组进行
去重（因为
对象是引用类型），需要通过 JSON 字符串化或其他方式来
实现自定义比较逻辑。
```
javascript
const arr = [
{ id: 1, name: "Alice" },
{ id: 2, name: "Bob" },
{ id: 1, name: "Alice" }
];
const uniqueArr = Array.from(
new Set(arr.
map(item => JSON.stringify(item)))
).
map(item => JSON.parse(item));
console.log(uniqueArr);
// 输出: [ { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' } ]
```
这种方法通过将
对象转换为字符串来
实现唯一性判断[^5]。
#### 2. 使用 `filter` 和 `findIndex`
通过 `filter` 方法结合 `findIndex`，可以筛选出唯一的
对象。
```
javascript
const arr = [
{ id: 1, name: "Alice" },
{ id: 2, name: "Bob" },
{ id: 1, name: "Alice" }
];
const uniqueArr = arr.filter((item, index) =>
arr.findIndex(obj => obj.id === item.id) === index
);
console.log(uniqueArr);
// 输出: [ { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' } ]
```
这种方法利用了 `findIndex` 的首次匹配特性，确保每个
对象只保留第一次出现的实例[^4]。
#### 3. 使用
Map 或 Weak
Map
通过 `
Map` 或 `Weak
Map` 存储已处理的
对象键值，可以高效地
实现去重。
```
javascript
const arr = [
{ id: 1, name: "Alice" },
{ id: 2, name: "Bob" },
{ id: 1, name: "Alice" }
];
const
map =
new Map();
const uniqueArr = arr.filter(item => {
if (
map.has(item.id)) return false;
map.set(item.id, true);
return true;
});
console.log(uniqueArr);
// 输出: [ { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' } ]
```
此方法通过 `
Map` 的键值存储特性，避免了
重复
对象的加入[^5]。
#### 4. Java 中的
对象数组去重
在 Java 中，可以通过集合类如 `HashSet` 来
实现对象数组的
去重。首先需要确保
对象类
实现了 `equals` 和 `hashCode` 方法。
```java
import java.util.*;
class Person {
int id;
String name;
Person(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return id == person.id && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public String toString() {
return "Person{id=" + id + ", name='" + name + "'}";
}
}
public class Main {
public static void main(String[] args) {
Person[] people = {
new Person(1, "Alice"),
new Person(2, "Bob"),
new Person(1, "Alice")
};
Set<Person> set =
new HashSet<>(Arrays.asList(people));
Person[] uniqueArray = set.toArray(
new Person[0]);
System.out.println(Arrays.toString(uniqueArray));
// 输出: [Person{id=1, name='Alice'}, Person{id=2, name='Bob'}]
}
}
```
这段代码展示了如何通过 `HashSet`
去重对象数组，并依赖 `equals` 和 `hashCode` 方法确保唯一性[^1]。
---
####
扫一扫
1583
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
