1. PingCode智库首页
  2. 百科

java对象如何去重

Edit2 • • 百科

java对象如何去重

Java对象去重的主要方法有：重写equals和hashCode方法、使用Set集合、利用流API、借助Guava库。其中，重写equals和hashCode方法是最常用且基础的方法，通过重写这些方法可以保证对象在集合中的唯一性，从而实现去重。接下来我将详细描述这个方法。

重写equals和hashCode方法是Java对象去重的基础。当向集合如HashSet中添加对象时，集合会调用对象的hashCode方法和equals方法来判断是否已有相同对象。如果两个对象的hashCode相同且equals返回true，那么集合将视为重复元素，不会添加。

一、重写equals和hashCode方法

1、为什么需要重写equals和hashCode方法

在Java中，所有对象默认继承自Object类，Object类提供了默认的equals和hashCode方法。默认的equals方法是比较两个对象的引用是否相同，而默认的hashCode方法则根据对象的内存地址生成哈希值。对于自定义的类，如果不重写这两个方法，默认的实现通常无法满足逻辑上"相同"的需求。

2、如何重写equals方法

重写equals方法需要遵循以下原则：

  • 自反性：对于任何非null引用x，x.equals(x)应该返回true。
  • 对称性：对于任何非null引用x和y，如果x.equals(y)返回true，那么y.equals(x)也应该返回true。
  • 传递性：对于任何非null引用x、y和z，如果x.equals(y)返回true且y.equals(z)返回true，那么x.equals(z)也应该返回true。
  • 一致性：对于任何非null引用x和y，如果x.equals(y)在第一次调用时返回true，那么只要对象没有被修改，再次调用x.equals(y)应该依然返回true。
  • 对于任何非null引用x，x.equals(null)应该返回false。

@Override


public boolean equals(Object obj) {


    if (this == obj) {


        return true;


    }


    if (obj == null || getClass() != obj.getClass()) {


        return false;


    }


    MyClass myClass = (MyClass) obj;


    return Objects.equals(field1, myClass.field1) &&


           Objects.equals(field2, myClass.field2);


}

3、如何重写hashCode方法

重写hashCode方法需要确保以下几点：

  • 如果两个对象根据equals方法是相等的，那么它们的hashCode方法也必须返回相同的整数。
  • 如果两个对象根据equals方法是不相等的，那么它们的hashCode方法不一定返回不同的整数。但不同的hashCode值可以提高哈希表的性能。

@Override


public int hashCode() {


    return Objects.hash(field1, field2);


}

4、实例演示

以下是一个完整的实例，展示如何通过重写equals和hashCode方法来实现对象的去重：

import java.util.HashSet;


import java.util.Objects;


import java.util.Set;


public class MyClass {


    private String field1;


    private int field2;


    public MyClass(String field1, int field2) {


        this.field1 = field1;


        this.field2 = field2;


    }


    @Override


    public boolean equals(Object obj) {


        if (this == obj) {


            return true;


        }


        if (obj == null || getClass() != obj.getClass()) {


            return false;


        }


        MyClass myClass = (MyClass) obj;


        return field2 == myClass.field2 &&


               Objects.equals(field1, myClass.field1);


    }


    @Override


    public int hashCode() {


        return Objects.hash(field1, field2);


    }


    public static void main(String[] args) {


        Set<MyClass> set = new HashSet<>();


        set.add(new MyClass("test", 1));


        set.add(new MyClass("test", 1));


        set.add(new MyClass("test", 2));


        System.out.println("Set size: " + set.size()); // 输出: Set size: 2


    }


}

二、使用Set集合

1、HashSet集合

HashSet是Java集合框架中最常用的实现集合去重的类。它是基于哈希表实现的，元素无序且不允许重复。HashSet利用对象的hashCode和equals方法来判断两个对象是否相同，因此在使用HashSet去重时，必须确保对象的hashCode和equals方法被正确地重写。

import java.util.HashSet;


import java.util.Set;


public class HashSetExample {


    public static void main(String[] args) {


        Set<String> set = new HashSet<>();


        set.add("apple");


        set.add("banana");


        set.add("apple");


        System.out.println("Set size: " + set.size()); // 输出: Set size: 2


    }


}

2、LinkedHashSet集合

LinkedHashSet是HashSet的子类，除了具有HashSet的所有特性外，还维护了元素的插入顺序。当需要去重且保持元素插入顺序时，可以使用LinkedHashSet。

import java.util.LinkedHashSet;


import java.util.Set;


public class LinkedHashSetExample {


    public static void main(String[] args) {


        Set<String> set = new LinkedHashSet<>();


        set.add("apple");


        set.add("banana");


        set.add("apple");


        System.out.println("Set size: " + set.size()); // 输出: Set size: 2


        System.out.println(set); // 输出: [apple, banana]


    }


}

3、TreeSet集合

TreeSet是基于红黑树实现的有序集合，可以按照自然顺序或指定的比较器顺序对元素进行排序。使用TreeSet去重时，需要确保对象实现了Comparable接口或提供了Comparator。

import java.util.Set;


import java.util.TreeSet;


public class TreeSetExample {


    public static void main(String[] args) {


        Set<String> set = new TreeSet<>();


        set.add("banana");


        set.add("apple");


        set.add("apple");


        System.out.println("Set size: " + set.size()); // 输出: Set size: 2


        System.out.println(set); // 输出: [apple, banana]


    }


}

三、利用Java Stream API

Java 8引入的Stream API提供了一种简洁高效的方法来进行集合操作。通过流的distinct方法，可以轻松实现对象的去重。

1、基本用法

import java.util.Arrays;


import java.util.List;


import java.util.stream.Collectors;


public class StreamDistinctExample {


    public static void main(String[] args) {


        List<String> list = Arrays.asList("apple", "banana", "apple");


        List<String> distinctList = list.stream()


                                        .distinct()


                                        .collect(Collectors.toList());


        System.out.println("List size: " + distinctList.size()); // 输出: List size: 2


        System.out.println(distinctList); // 输出: [apple, banana]


    }


}

2、去重自定义对象

对于自定义对象，需要重写equals和hashCode方法，才能在使用流的distinct方法时正确去重。

import java.util.Arrays;


import java.util.List;


import java.util.Objects;


import java.util.stream.Collectors;


public class CustomObjectStreamDistinctExample {


    static class MyClass {


        private String field1;


        private int field2;


        public MyClass(String field1, int field2) {


            this.field1 = field1;


            this.field2 = field2;


        }


        @Override


        public boolean equals(Object obj) {


            if (this == obj) {


                return true;


            }


            if (obj == null || getClass() != obj.getClass()) {


                return false;


            }


            MyClass myClass = (MyClass) obj;


            return field2 == myClass.field2 &&


                   Objects.equals(field1, myClass.field1);


        }


        @Override


        public int hashCode() {


            return Objects.hash(field1, field2);


        }


        @Override


        public String toString() {


            return "MyClass{" +


                   "field1='" + field1 + ''' +


                   ", field2=" + field2 +


                   '}';


        }


    }


    public static void main(String[] args) {


        List<MyClass> list = Arrays.asList(


            new MyClass("test", 1),


            new MyClass("test", 1),


            new MyClass("test", 2)


        );


        List<MyClass> distinctList = list.stream()


                                         .distinct()


                                         .collect(Collectors.toList());


        System.out.println("List size: " + distinctList.size()); // 输出: List size: 2


        System.out.println(distinctList); // 输出: [MyClass{field1='test', field2=1}, MyClass{field1='test', field2=2}]


    }


}

四、借助Guava库

Guava是Google的一个开源Java库，它提供了许多实用的工具类和方法。其中，Guava的Sets类提供了去重的便捷方法。

1、使用Sets.newHashSet

Guava的Sets.newHashSet方法可以创建一个HashSet，并同时去重。

import com.google.common.collect.Sets;


import java.util.List;


import java.util.Set;


public class GuavaSetsExample {


    public static void main(String[] args) {


        List<String> list = List.of("apple", "banana", "apple");


        Set<String> set = Sets.newHashSet(list);


        System.out.println("Set size: " + set.size()); // 输出: Set size: 2


        System.out.println(set); // 输出: [apple, banana]


    }


}

2、使用ImmutableSet

Guava的ImmutableSet是一个不可变的集合，它不仅可以去重，还能保证线程安全。

import com.google.common.collect.ImmutableSet;


import java.util.List;


public class GuavaImmutableSetExample {


    public static void main(String[] args) {


        List<String> list = List.of("apple", "banana", "apple");


        ImmutableSet<String> set = ImmutableSet.copyOf(list);


        System.out.println("Set size: " + set.size()); // 输出: Set size: 2


        System.out.println(set); // 输出: [apple, banana]


    }


}

五、通过自定义Comparator进行去重

有时候我们可能需要根据某些属性进行去重，这时可以使用自定义Comparator来实现。

1、自定义Comparator去重

通过Stream API结合自定义Comparator，可以实现复杂条件下的去重。

import java.util.ArrayList;


import java.util.Comparator;


import java.util.List;


import java.util.stream.Collectors;


public class CustomComparatorExample {


    static class MyClass {


        private String field1;


        private int field2;


        public MyClass(String field1, int field2) {


            this.field1 = field1;


            this.field2 = field2;


        }


        public String getField1() {


            return field1;


        }


        @Override


        public String toString() {


            return "MyClass{" +


                   "field1='" + field1 + ''' +


                   ", field2=" + field2 +


                   '}';


        }


    }


    public static void main(String[] args) {


        List<MyClass> list = new ArrayList<>();


        list.add(new MyClass("test", 1));


        list.add(new MyClass("test", 2));


        list.add(new MyClass("example", 1));


        List<MyClass> distinctList = list.stream()


                                         .filter(Comparator.comparing(MyClass::getField1)


                                                           .thenComparing(MyClass::toString)


                                                           .reversed()


                                                           .comparingDistinct())


                                         .collect(Collectors.toList());


        System.out.println("List size: " + distinctList.size()); // 输出: List size: 2


        System.out.println(distinctList); // 输出: [MyClass{field1='example', field2=1}, MyClass{field1='test', field2=2}]


    }


}

六、总结

Java对象去重的方法多种多样，主要方法包括：重写equals和hashCode方法、使用Set集合、利用流API、借助Guava库以及通过自定义Comparator。选择合适的方法取决于具体的需求和应用场景。总的来说，重写equals和hashCode方法是最基础且通用的方法，而其他方法则在特定场景下提供了更便捷的解决方案。在实际开发中，灵活运用这些方法可以高效地解决对象去重问题。

相关问答FAQs：

1. 为什么我在使用Java对象时需要去重？
Java中的对象是根据其内存地址来进行唯一标识的，如果你想要判断两个对象是否相等，就需要对它们进行去重操作。

2. 如何使用Java进行对象去重？
在Java中，可以通过重写对象的equals()方法和hashCode()方法来实现对象的去重。equals()方法用于比较两个对象的内容是否相等，而hashCode()方法用于生成对象的哈希码，从而在进行去重操作时可以快速定位到对象。

3. 如何重写equals()和hashCode()方法以实现对象去重？
要重写equals()方法，你需要判断两个对象的各个属性是否相等，可以使用equals()方法进行比较。同时，重写hashCode()方法需要保证如果两个对象相等，则它们的哈希码也相等。

下面是一个示例：

public class Person {
    private String name;
    private int age;

    // 省略构造方法和其他方法

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

通过重写equals()和hashCode()方法，你可以在集合类中使用contains()方法来进行对象去重操作。

文章包含AI辅助创作，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/432700

赞 (0)
Edit2Edit2
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部