在
Java 中，判断
对象集合中
两个属性值是否
重复，可以使用多种方式实现。
### 方式一：传统的双重循环
通过双重循环遍历
集合，比较每
两个元素的
两个属性值是否都相同。
```
java
import
java.util.ArrayList;
import
java.util.List;
class Person {
private
String name;
private int age;
public Person(
String name, int age) {
this.name = name;
this.age = age;
}
public
String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class DuplicateCheck {
public static boolean hasDuplicateProperties(List<Person> list) {
for (int i = 0; i < list.size(); i++) {
for (int j = i + 1; j < list.size(); j++) {
Person p1 = list.get(i);
Person p2 = list.get(j);
if (p1.getName().
equals(p2.getName()) && p1.getAge() == p2.getAge()) {
return true;
}
}
}
return false;
}
public static void main(
String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 25));
people.add(new Person("Bob", 30));
people.add(new Person("Alice", 25));
boolean result = hasDuplicateProperties(people);
System.out.println("是否有
重复属性: " + result);
}
}
```
这种方式简单直接，但时间复杂度为 $O(n^2)$，当
集合元素较多时，性能较低。
### 方式二：使用
Java 8 Stream API 和自定义
对象作为键
将
两个属性组合成一个自定义
对象作为键，使用 `Collectors.groupingBy` 进行分组，然后检查是否有分组的元素数量大于 1。
```
java
import
java.util.ArrayList;
import
java.util.List;
import
java.util.Map;
import
java.util.stream.Collectors;
class Person {
private
String name;
private int age;
public Person(
String name, int age) {
this.name = name;
this.age = age;
}
public
String getName() {
return name;
}
public int getAge() {
return age;
}
// 自定义
对象用于作为键
static class NameAgeKey {
private final
String name;
private final int age;
public NameAgeKey(
String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean
equals(
Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
NameAgeKey that = (NameAgeKey) o;
return age == that.age && name.
equals(that.name);
}
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + age;
return result;
}
}
}
public class DuplicateCheckStream {
public static boolean hasDuplicateProperties(List<Person> list) {
Map<Person.NameAgeKey, Long> groups = list.stream()
.collect(Collectors.groupingBy(person -> new Person.NameAgeKey(person.getName(), person.getAge()), Collectors.counting()));
return groups.values().stream().anyMatch(count -> count > 1);
}
public static void main(
String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 25));
people.add(new Person("Bob", 30));
people.add(new Person("Alice", 25));
boolean result = hasDuplicateProperties(people);
System.out.println("是否有
重复属性: " + result);
}
}
```
这种方式利用了 Stream API 和 `Collectors.groupingBy` 方法，代码更简洁，且性能相对较好，时间复杂度接近 $O(n)$。
### 方式三：使用 `Set` 存储组合键
将
两个属性组合成一个字符串作为键，存储在 `Set` 中，利用 `Set` 的特性判断是否有
重复。
```
java
import
java.util.ArrayList;
import
java.util.
HashSet;
import
java.util.List;
import
java.util.Set;
class Person {
private
String name;
private int age;
public Person(
String name, int age) {
this.name = name;
this.age = age;
}
public
String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class DuplicateCheckSet {
public static boolean hasDuplicateProperties(List<Person> list) {
Set<
String> keySet = new
HashSet<>();
for (Person person : list) {
String key = person.getName() + "-" + person.getAge();
if (!keySet.add(key)) {
return true;
}
}
return false;
}
public static void main(
String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 25));
people.add(new Person("Bob", 30));
people.add(new Person("Alice", 25));
boolean result = hasDuplicateProperties(people);
System.out.println("是否有
重复属性: " + result);
}
}
```
这种方式也是 $O(n)$ 的时间复杂度，通过 `Set` 的 `add` 方法的返回值判断是否有
重复元素。
本文深入探讨了HashSet的工作原理，包括对象的重复性定义、equals方法与hashCode方法的关系以及它们如何共同确保集合内元素的唯一性。
扫一扫
960
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
