Java 8 - 根据类的某个或多个属性去重

1. 基本类型数据进行去重
方法1:使用 HashSet

	public class MainDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 5, 5, 5, 6, 7);
        Set<Integer> set = new HashSet<>(numbers);
        System.out.println(set); //1, 2, 3, 4, 5, 6, 7
    }
}

方法2:使用 java 8 stream 中的 distinct() 方法

public class MainDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 5, 5, 5, 6, 7);
        List<Integer> distinctNumbers = numbers.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(distinctNumbers); //1, 2, 3, 4, 5, 6, 7
    }
}

2. 根据类的某个属性去重
根据对象的某个属性去重

@AllArgsConstructor
@Data
public class People{
    private String name;
    private String phone;
    private Integer age;
}
public class Main {
    public static void main(String[] args) {
        People people1 = new People("张三","18767880909",18);
        People people2 = new People("张四","18767880910",19);
        People people3 = new People("张五","18767880911",20);
        People people4 = new People("张六","18767880912",18);
        People people5 = new People("张三","18767880909",19);
        People people6 = new People("张四","18767880910",20);

        List<People> list = new ArrayList<>();
        list.add(people1);
        list.add(people2);
        list.add(people3);
        list.add(people4);
        list.add(people5);
        list.add(people6);
        
        // 根据People的name属性去重
        List<People> collect = list.stream().distinct()
                .filter(distinctByKey(People::getName))
                .collect(Collectors.toList());
        
        for (People people : collect) {
            System.out.println(people);
        }
    }
    
   // 首先定义一个过滤器 
    public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return object -> seen.putIfAbsent(keyExtractor.apply(object), Boolean.TRUE) == null;
    }
}

执行结果:

People(name=张三, phone=18767880909, age=18)
People(name=张四, phone=18767880910, age=19)
People(name=张五, phone=18767880911, age=20)
People(name=张六, phone=18767880912, age=18)

3. 根据类的多个属性去重
下面的两种去重方法都需要People类重写hashcode()方法和equals()方法:

@AllArgsConstructor
@Data
public class People{
    private String name;
    private String phone;
    private Integer age;

    // 重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        People that = (People) o;
        return Objects.equals(name, that.name) && Objects.equals(phone, that.phone);
    }

    // 重写hashcode()方法
    @Override
    public int hashCode() {
        return Objects.hash(name, phone);
    }
}

方法1:使用 HashSet
我们的类必须实现hashCode()和equals()方法。

public class Main {
    public static void main(String[] args) {
        People people1 = new People("张三","18767880909",18);
        People people2 = new People("张四","18767880910",19);
        People people3 = new People("张五","18767880911",20);
        People people4 = new People("张六","18767880912",18);
        People people5 = new People("张三","18767880909",19);
        People people6 = new People("张四","18767880910",20);

        List<People> list = new ArrayList<>();
        list.add(people1);
        list.add(people2);
        list.add(people3);
        list.add(people4);
        list.add(people5);
        list.add(people6);

        // hashset 
        HashSet<People> set = new HashSet<>(list);
        
        for (People people : set) {
            System.out.println(people);
        }
    }
}
People(name=张三, phone=18767880909, age=18)
People(name=张四, phone=18767880910, age=19)
People(name=张六, phone=18767880912, age=18)
People(name=张五, phone=18767880911, age=20)

方法2:使用 java 8 stream 中的 distinct() 方法
distinct()方法使用hashCode()和equals()方法来获取不同的元素。所以,我们的类必须实现hashCode()和equals()方法。

public class Main {
    public static void main(String[] args) {
        People people1 = new People("张三","18767880909",18);
        People people2 = new People("张四","18767880910",19);
        People people3 = new People("张五","18767880911",20);
        People people4 = new People("张六","18767880912",18);
        People people5 = new People("张三","18767880909",19);
        People people6 = new People("张四","18767880910",20);

        List<People> list = new ArrayList<>();
        list.add(people1);
        list.add(people2);
        list.add(people3);
        list.add(people4);
        list.add(people5);
        list.add(people6);

        // distinct
        List<People> collect = list.stream().distinct().collect(Collectors.toList());
        
        for (People people : collect) {
            System.out.println(people);
        }
    }
}

执行结果:

People(name=张三, phone=18767880909, age=18)
People(name=张四, phone=18767880910, age=19)
People(name=张六, phone=18767880912, age=18)
People(name=张五, phone=18767880911, age=20)

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
如果你想根据一个对象的某个属性对整个集合进行去重,可以按照以下步骤进行操作: 1. 创建一个新的集合来存储去重后的对象。 2. 遍历原始集合中的每个对象。 3. 对于每个对象,提取出你想要用来进行去重属性值。 4. 检查新集合中是否已经存在具有相同属性值的对象。 5. 如果新集合中不存在具有相同属性值的对象,则将当前对象添加到新集合中。 以下是一个示例代码,演示如何根据对象的某个属性对集合进行去重: ```java import java.util.HashSet; import java.util.Set; public class Main { public static void main(String[] args) { // 创建一个包含多个对象的集合 Set<Person> originalSet = new HashSet<>(); originalSet.add(new Person("John", 25)); originalSet.add(new Person("Alice", 30)); originalSet.add(new Person("John", 25)); // 重复属性 originalSet.add(new Person("Bob", 35)); System.out.println("原始集合:" + originalSet); // 创建一个新的集合来存储去重后的对象 Set<Person> uniqueSet = new HashSet<>(); for (Person person : originalSet) { // 提取出用于去重属性值 String name = person.getName(); // 检查新集合中是否已经存在具有相同属性值的对象 boolean alreadyExists = uniqueSet.stream().anyMatch(p -> p.getName().equals(name)); // 如果新集合中不存在具有相同属性值的对象,则将当前对象添加到新集合中 if (!alreadyExists) { uniqueSet.add(person); } } System.out.println("根据属性去重后的集合:" + uniqueSet); } public static 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; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } } } ``` 运行上述代码,输出结果如下: ``` 原始集合:[Person{name='Alice', age=30}, Person{name='John', age=25}, Person{name='Bob', age=35}] 根据属性去重后的集合:[Person{name='Alice', age=30}, Person{name='John', age=25}, Person{name='Bob', age=35}] ``` 可以看到,根据对象的name属性对集合进行了去重,得到了一个新的集合。在这个例子中,重复的对象被过滤掉了。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

macrohua

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值