Java - Hacer una colección de objetos amigable

Question

Si un objeto tiene una clave primaria única, ¿qué interfaces necesita implementar para ser amigable con la recopilación especialmente en términos de ser ordenable de manera eficiente, hashable, etc.?

Si la clave principal es una cadena, ¿cómo se implementan mejor estas interfaces?

Gracias!

Answer 1

Debe anular Object.equals() y Object.hashCode(), y también implementar la interfaz Comparable. Esto hará que tu clase sea completamente "compatible" cuando realices cualquier tipo de clasificación o hash, incluso usando Collections.sort(, cualquier clase Map o cualquier clase Set. Si hay incluso una diminuta posibilidad de que la clase se ponga en algún tipo de colección, entonces debería definitivamente implementar los tres de estos métodos.

public class A implements Comparable<A>{ 
    private String key; 

    @Override 
    public boolean equals(Object obj){ 
     if (this == obj) return true; 
     if (!(obj instanceof A)) return false; 

     A that = (A)obj; 
     return this.key.equals(that.key);  
    } 

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

    @Override 
    public int compareTo(A that){ 
     //returns -1 if "this" object is less than "that" object 
     //returns 0 if they are equal 
     //returns 1 if "this" object is greater than "that" object 
     return this.key.compareTo(that.key); 
    } 
} 

Tenga en cuenta que si dos objetos son iguales, entonces:

1. sus códigos hash también deben ser iguales y
2. compareTo() deben devolver 0.

Answer 2

Debe implementar equals, hashCode y (después de implementar la interfaz Comparable) compareTo.

En cada caso, dado que tiene una cadena que es una clave principal, puede considerar simplemente enviar estas llamadas a su cadena. Por ejemplo:

public class Friendly implements Comparable<Friendly> 
{ 
    // presumably you've got other fields as well 
    private String primaryKey; 
    public Friendly(String primaryKey) 
    { 
     this.primaryKey = primaryKey; 
    } 

    public int compareTo(Friendly other) 
    { 
     return primaryKey.compareTo(other.primaryKey); 
    } 

    public int hashCode() 
    { 
     return primaryKey.hashCode(); 
    } 

    public boolean equals(Object o) 
    { 
     return (o instanceof Friendly) && primaryKey.equals(((Friendly)o).primaryKey); 
    } 
} 

Answer 3

Cuerdas ya son muy adecuadas para hash y comparación, así que si los objetos realmente puede ser identificada por las cuerdas, entonces están en buena forma. Solo asegúrese de implementar la interfaz Comparable para ordenar e invalidar equals y hashCode (delegando en la cadena de clave principal) para el hashing y listo.

Answer 4

Si la clave principal es Object, debe decidir si la clasificación se basa en la clave principal Object o ObjectObject.

En cualquier caso, el elemento que se va a ordenar debe implementar la interfaz Comparable, con un método adecuado compareTo(). Las probabilidades son excelentes, lo que significa que tendrá que anular equals() y hashCode() también, ya que solo algunos de los Objetos de la clave principal probablemente tengan las implementaciones predeterminadas adecuadas.

Si desea ordenar en función de un orden de clasificación no natural, implemente también algunos "adicionales" Comparators. Ordenado Collections soporte alternativo Comparators.