È corretto per equals() dipendere solo da un ID?

Question

Supponiamo Ho classe User:

public class User { 
    private Long id; 
    private String name; 
    private Integer age; 
    private BigDecimal account; 
    // other fields, getters and setters 
} 

E 'proprio l'override del metodo equals come segue?

@Override 
public boolean equals(Object ob) { 
    if (ob == null) { 
     return false; 
    } 
    if (this == ob) { 
     return true; 
    } 
    if (ob instanceof User) { 
     User other = (User) ob; 
     return this.id.equals(other.getId()); 
    } 
    return false; 
} 

Si scopre che l'unicità di un oggetto è determinata solo dal suo ID. Ma nella mia applicazione, id è sempre univoco. È fornito nel database. La mia implementazione equals è sufficientemente competente per tener conto di ciò? O non è questa la migliore pratica?

Naturalmente capisco che in questo caso l'attuazione hashCode dovrebbe essere la seguente:

@Override 
public int hashCode() { 
    return id.intValue(); 
} 

Answer 1

Va bene. Fintanto che due utenti diversi non possono avere lo stesso ID, la tua funzione equals è sufficiente. Ci potrebbe essere un problema se un utente può essere rappresentato due volte con un ID diverso (per qualsiasi motivo) e si vuole considerarli uguali.

Answer 2

tuoi equals() Metodo dosen't guardare come è stato generato da IDE in quanto non controlla 'id' valore nullo come dichiarato da @Eric ..

questo è ciò che i miei equals()/metodo hashCode() sembrava utilizzando stesso ID prop

@Override 
public int hashCode() { 
    final int prime = 31; 
    int result = 1; 
    result = prime * result + ((id == null) ? 0 : id.hashCode()); 
    return result; 
} 

@Override 
public boolean equals(Object obj) { 
    if (this == obj) 
     return true; 
    if (obj == null) 
     return false; 
    if (getClass() != obj.getClass()) 
     return false; 
    User11 other = (User11) obj; 
    if (id == null) { 
     if (other.id != null) 
      return false; 
    } else if (!id.equals(other.id)) 
     return false; 
    return true; 
} 

dovremmo sempre utilizzare la generazione automatica di codice standard dove possibile, in quanto è molto meno soggetto ad errori.

inoltre, per quanto riguarda il tuo punto riguardante l'unicità del puntello "id", che dipende dalle tue preferenze e da come vuoi utilizzare il metodo equals (requisiti aziendali) cioè se il nome di due utenti è lo stesso devono essere considerati uguali quando si confrontano due oggetti utente più avanti ..

Answer 3

Se si dovrebbe fare questo dipende dalla semantica della classe. Cioè, che cosa significa significa dire che due oggetti della tua classe sono equivalenti? La distinzione più importante è tra oggetti con semantica del valore e oggetti con semantica delle entità. Gli oggetti entità non sono equivalenti anche se hanno attributi equivalenti (colore, lunghezza, ecc.). In molti casi, anche quando l'oggetto è stato letto da una tabella di database che ha una chiave primaria, gli oggetti entità avranno un campo ID univoco. Confrontare solo il campo ID in quel caso è la cosa giusta da fare.

Answer 4

È corretto utilizzare l'id per il metodo equals a condizione che non sia necessario confrontare un'entità che non è stata ancora salvata nel DB. Se vuoi confrontare entità che non sono state ancora salvate, dovrai confrontare i loro attributi.

Answer 5

Sono d'accordo che è sull'id. Ma ho avuto problemi nel ricevere dati che dovrebbero aggiornare il database. Con questo esempio con Utente a cui è uguale solo l'ID, l'ho creato.

interface DataEquals<T extends DataEquals> { 
    public boolean isDataEquals(T other) 
} 


User implements DataEquals<User> { 
    public boolean isDataEquals(User other) { 
     boolean b1 = getName().equals(other.getName()); 
     boolean b2 = getAge().equals(other.getAge()); 
     boolean b3 = getAccount().equals(other.getAccount()); 
     return b1 && b2 && b3; 
    } 
} 

Con questo possiamo avere questo.

public class ListChanges<T extends DataEquals<T>> { 

    private List<T> added = new ArrayList<T>(); 
    private List<T> removed = new ArrayList<T>(); 
    private List<T> changed = new ArrayList<T>(); 
    private List<T> unchanged = new ArrayList<T>(); 

    public ListChanges() { 
    super(); 
    } 
    public List<T> getAdded() { 
    return added; 
    } 
    public List<T> getChanged() { 
    return changed; 
    } 
    public List<T> getRemoved() { 
    return removed; 
    } 
    public List<T> getUnchanged() { 
    return unchanged; 
    } 

    public boolean hasAnyChanges() { 
    return added.size()>0 || removed.size()>0 || changed.size()>0; 
    } 

    public void parse(List<T> oldList,List<T> newList) { 
    for (T oldObj : oldList) { 
     int index =newList.indexOf(oldObj); 
     if (index==-1) { 
      removed.add(oldObj); 
     } else { 
      T newObj = newList.get(index); 

      if (newObj.isDataEquals(oldObj)) { 
       unchanged.add(oldObj); 
      } else { 
       changed.add(newObj); 
      } 
     } 
    } 
    for (T newObj : newList) { 
     if (oldList.indexOf(newObj)==-1) { 
      added.add(newObj); 
     } 
    } 
} 
} 

allora possiamo fare questo

List<User> oldList = ....; 
List<User> newList = ...; 
ListChanges<User> listChanges = new ListChanges<User>(); 
listChanges.parseChanges(oldList,newList); 

Siete d'accordo che questo è un modo per fare questo. ??????