如何确保在java中只创建唯一的对象？

Question

这是一个面试问题，我一片空白，没有任何想法。假设我有一个Employee类，它有三个字段EmpId、EmpName和EmpAddress。

现在我的工作是确保我创建的所有对象在EmpId的基础上是唯一的，这样当我尝试创建两个具有相同EmpId的对象时，必须有一种机制来停止/警告我，也许编译器警报或任何逻辑都可以。

我在面试中唯一能想到的就是使用Map (即HashMap)的密钥作为EmpId，以确保唯一性。我知道DB中的主键可以确保这一点，但是我如何在Java中处理这一点呢？

任何关于这一行的建议/想法都将不胜感激。

Answer 1

我认为您可以使用HashSet或其他类集的实现来解决您的问题，并覆盖方法equals以避免类的重复条目。

来自类集合的Java 的

集合框架接口中的许多方法都是根据equals方法定义的。

N.B. HashSet和Set实现接口集合

我将向您展示一个使用方法contains避免重复的示例

来自Java 的方法包含的类集的

布尔contains(对象o)

如果此集合包含指定的元素，则返回true。更正式地说，如果且仅当此集合包含至少一个元素e (o==null？e==null : o.equals(e))。

在这段代码中，我使用了一个静态HashSet来拥有Employee的惟一列表。仅当在HashSet中成功插入元素时，才能使用返回true的addToSet方法在集合中插入元素。

import java.util.HashSet; 

public class Employee {
    private static HashSet<Employee> EmpSet= new HashSet<>();
    private String EmpId, EmpName, EmpAddress;
    
    public Employee(String id, String name, String addr){
        EmpId = id;
        EmpName = name;
        EmpAddress = addr;
    }
    
    public static boolean addToSet(Employee employee){  //this can be synchronized if you need
        if(EmpSet.contains(employee))
            return false;
        else
            EmpSet.add(employee);
        return true;
    }
    
    @Override
    public boolean equals(Object to_compare){
        if( !(to_compare instanceof Employee))
            return false;
        Employee other = (Employee) to_compare;
        return this.EmpId.equals(other.EmpId);
    }
}

如果EmpId为整型或长整型，则显示的代码也适用。如果您从多个线程使用这个类，那么可以按照注释中的建议使方法addToSet同步。

如果您使用的是数据库，则此代码无效，您可以找到针对特定情况的特定方法。

编辑添加我很抱歉，实际上您不需要addToSet方法，因为HashMap类的方法add执行的是完全相同的操作，所以您可以使用它的方法，或者简单地：

public static boolean addToSet(Employee employee){  //this can be synchronized if you need
                EmpSet.add(employee);
        }

Answer 2

正如其他人所说，您可以使用Map或Set来保存集合，并覆盖equals和hashCode方法以确保在集合中正确使用。

如果你想检查对象的创建，你可以使用Map并抛出一个异常：

import java.util.Set;
import java.util.HashSet;    

public class Employee {

    private static Map<EmpID, Employee> employees = new HashMap<EmpID, Employee>();

    private EmpId empID;
    private EmpName empName;
    private EmpAddress address;

    public Employee(EmpID empID, EmpName empName, EmpAddress empAddress) throws NotUniqueIDException {            
        if(!employees.keySet().contains(empID) {
            this.empID = empID;
            this.empName = empName;
            this.empAddress = empAddress;
            employees.put(empID, this);
        } else {
            // Error
            throw NotUniqueIDException();
        }
    }

然后，在使用时：

try {
    Employee employee = new Employee(empID, empName, empAddress);
} catch(NotUniqueIDException exception) {
    // Do something here
}

至于是否需要生成惟一的if，UUID.randomUUID()可能是个不错的选择

Answer 3

很简单，我们需要重写equals()方法，黄金法则是，当你重写equals()时，我们必须重写hascode()。

下面是这方面的工作代码

    class Employee
    {
        private Integer id;
        private String firstname;
        private String lastName;
        private String department;
    
        Employee(Integer id, String firstname, String lastName, String department) {
            this.id = id;
            this.firstname = firstname;
            this.lastName = lastName;
            this.department = department;
        }
    
        public Integer getId() {
            return id;
        }
        
        public String getFirstname() {
            return firstname;
        }
        
        public String getLastName() {
            return lastName;
        }
        
        public String getDepartment() {
            return department;
        }
        
        public boolean equals(Object o) {
            if(o == null)
            {
                return false;
            }
            if (o == this)
            {
                return true;
            }
            if (getClass() != o.getClass())
            {
                return false;
            }
    
            Employee e = (Employee) o;
            return (this.getId() == e.getId());
        }
        
    
        public int hashCode()
        {
            final int PRIME = 31;
            int result = 1;
            result = PRIME * result + getId();
            return result;
        }
    }

驱动程序类

public class Test {

    public static void main(String[] args) {
        Employee e1 = new Employee(100,"Arpit","Agarwal","SDET");
        Employee e2 = new Employee(101,"Neha","Agrawal","Web Developer");
        Employee e3 = new Employee(103,"Priya","Gupta","Data Science");
        Employee e4 = new Employee(100,"Mohit","Verma","Dev ops");
        Set<Employee> mySet = new LinkedHashSet<>();
        mySet.add(e1);
        mySet.add(e2);
        mySet.add(e3);
        mySet.add(e4);
        for(Employee obj : mySet)   {
            System.out.println(obj.getId() + ", " + obj.getFirstname() + ", " + obj.getLastName() + ", " + obj.getDepartment());
        }
    }
}