Java hashCode para una clase de punto

Question

Tengo una clase de punto personalizada simple de la siguiente manera y me gustaría saber si mi implementación hashCode podría mejorarse o si esto es lo mejor que va a obtener.

public class Point 
{ 
    private final int x, y; 

    public Point(int x, int y) 
    { 
     this.x = x; 
     this.y = y; 
    } 

    public int getX() 
    { 
     return x; 
    } 

    public int getY() 
    { 
     return y; 
    } 

    @Override 
    public boolean equals(Object other) 
    { 
     if (this == other) 
      return true; 

     if (!(other instanceof Point)) 
      return false; 

     Point otherPoint = (Point) other; 
     return otherPoint.x == x && otherPoint.y == y; 
    } 


    @Override 
    public int hashCode() 
    { 
     return (Integer.toString(x) + "," + Integer.toString(y)).hashCode(); 
    } 

} 

Answer 1

No utilice cadenas. Existe una gran cantidad de teoría detrás de esto y varias implementaciones (método de división, multiplicación uno, etc.). Si usted tiene acerca de una hora se puede ver este MIT-Class

Dicho esto, aquí es lo que Netbeans 7.1 sugiere:

@Override 
public int hashCode() { 
    int hash = 7; 
    hash = 71 * hash + this.x; 
    hash = 71 * hash + this.y; 
    return hash; 
} 

de octubre de el año 2015 Editar

que empecé a usar IntelliJ hace un tiempo, Yo vivo más feliz ahora. Esto es lo que produce su generación automática hashCode. Es un poco menos detallado. Tenga en cuenta el uso de números primos también.

@Override 
public int hashCode() { 
    int result = x; 
    result = 31 * result + y; 
    return result; 
} 

Answer 2

solía escribir mi propio hash y las funciones de igual luego me encontré esto:)

import org.apache.commons.lang.builder.HashCodeBuilder; 
import org.apache.commons.lang.builder.EqualsBuilder; 

@Override 
public boolean equals(Object obj) { 
    return EqualsBuilder.reflectionEquals(this, obj); 
} 
@Override 
public int hashCode() { 
    return HashCodeBuilder.reflectionHashCode(this); 
} 

, por supuesto, tener en cuenta lo siguiente:

Debido a la reflexión, a otros tipos que son resuelto dinámicamente, ciertas optimizaciones de la máquina virtual Java no se pueden realizar. En consecuencia, las operaciones reflexivas tienen un rendimiento más lento que sus contrapartes no reflectantes , y deben evitarse en las secciones de código que se llaman con frecuencia en aplicaciones sensibles al rendimiento. SRC

Answer 3

yo recomendaría usar un método más simple y más performante sin condiciones, tal vez el método de Josh Bloch de this answer, en su caso, simplemente:

return 37 * x + y; 

EDIT: nybbler es correcta. Lo que realmente está recomendada es:

int result = 373; // Constant can vary, but should be prime 
result = 37 * result + x; 
result = 37 * result + y; 

Answer 4

de la clase Punto de JDK (heredado de POINT2D):

public int hashCode() { 
    long bits = java.lang.Double.doubleToLongBits(getX()); 
    bits ^= java.lang.Double.doubleToLongBits(getY()) * 31; 
    return (((int) bits)^((int) (bits >> 32))); 
} 

Eso se ve un poco mejor que su puesta en práctica.

Answer 5

Usted puede tener una mirada en clases de implementaciones de tipos de punto existente:

/** 
343  * Returns the hashcode for this <code>Point2D</code>. 
344  * @return a hash code for this <code>Point2D</code>. 
345  */ 
346  public int hashCode() { 
347  long bits = java.lang.Double.doubleToLongBits(getX()); 
348  bits ^= java.lang.Double.doubleToLongBits(getY()) * 31; 
349  return (((int) bits)^((int) (bits >> 32))); 
350  } 

de: http://kickjava.com/src/java/awt/geom/Point2D.java.htm#ixzz1lMCZCCZw

guía simple para la aplicación hashCode se pueden encontrar here

Answer 6

Por defecto, Eclipse utilizará una Función hashCode() para su clase Point similar a:

@Override 
public int hashCode() { 
    final int prime = 31; 
    int result = 1; 
    result = prime * result + getOuterType().hashCode(); 
    result = prime * result + x; 
    result = prime * result + y; 
    return result; 
} 

Por lo menos, incorporar un número primo en su algoritmo hashCode ayudará con su "singularidad".

Answer 7

La multiplicación manual de los valores de todos los campos de miembros importantes como sugiere Gevorg es probablemente la más eficiente y tiene una buena distribución de valores. Sin embargo, si usted a favor de la legibilidad, hay buenas alternativas disponibles ya sea en Java 7 ...

import java.util.Objects; 

... 

@Override 
public int hashCode() { 
    return Objects.hash(x, y); 
} 

... o en el Guava biblioteca:

import com.google.common.base.Objects; 

.... 

@Override 
public int hashCode() { 
    return Objects.hashCode(x, y); 
} 

Ambos métodos varags simplemente delegar en Arrays.hashCode(Object[] a), por lo que hay un ligero impacto en el rendimiento debido al autoboxing de entradas y la creación de una matriz de referencias a objetos, pero debería ser mucho menos importante que usar la reflexión.

Y la legibilidad es simplemente genial, ya que sólo tiene que ver, qué campos se utilizan para el cálculo código hash y toda la multiplican y agregar la sintaxis es sólo oculta bajo el capó de Arrays.hashCode(Object[] a):

public static int hashCode(Object a[]) { 
    if (a == null) 
     return 0; 

    int result = 1; 

    for (Object element : a) 
     result = 31 * result + (element == null ? 0 : element.hashCode()); 

    return result; 
}