Unique Objects into list in java

If you want certain containers to work that are able to prevent duplicates of your Employee from being added you need to define how equals is calculated in Employee.

public class Employee {
//...
    @Override
    public boolean equals(Object obj) {
       if (!(obj instanceof Person))
            return false;
        if (obj == this)
            return true;

        Person rhs = (Person) obj;
        return new EqualsBuilder()
            // if deriving: .appendSuper(super.equals(obj))
            .append(employeeId, rhs.employeeId)
            .append(firstName, rhs.firstName)
            .append(lastName, rhs.lastName)
            .isEquals();
    }
}

If you want certain containers to work that are able to look up your Employee quickly you need to define how hashcode is calculated in Employee.

public class Employee {
//...
    @Override
    public int hashCode() {
        int hash = 1;
        hash = hash * 17 + employeeId;
        hash = hash * 31 + firstName.hashCode();
        hash = hash * 13 + lastName.hashCode();
        return hash;
    }
}

Most modern IDE's will offer a re-factoring to do this for you. Use the same fields in both so they change together.

Since you don't want duplicates you're best bet is to not use ArrayList but something that pays attention to the hash and will enforce uniqueness for you. Whenever I'm picking a container in java I look at this:

To have all of those available to you, you need to implement not only hashcode and equals but comparator as well.

Just to be clear, the point of the hash is to provide lookup speed. The point of equals is to define what objects are considered identical. The point of comparator is to provide an ordering for the objects.

If you want to include the less frequently used containers try this:

This can be achieved by overwriting the methods equals() and hashCode() - then you can turn to existing java.util collection classes (like HashSet) that use these methods when comparing objects.

Here, equals() & hashCode() methods are overridden to meet the given requirements.

class Employee {
    protected long   employeeId;
    protected String firstName;
    protected String lastName;

    Employee(long employeeId,String firstName,String lastName){
        this.employeeId = employeeId;
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public boolean equals(Object o){
        if(o == null) return false;
        if(!(o instanceof) Employee) return false;

        Employee other = (Employee) o;
        if(this.employeeId != other.employeeId)      return false;
        if(! this.firstName.equals(other.firstName)) return false;

        return true;
   }

    public int hashCode(){
        return (int) employeeId * firstName.hashCode();
    }
}

Here, if two Employee objects are equal, they will also have the same hash code. But, even still two Employee objects can be not equal having the same hash code.

Ex: The hash code is the employeeId is rounded down to an int. That means that many employee id's could result in the same hash code, but these Employee objects would still not be equal, since they don't have the same employee id.