Comment utiliser deux numéros d'une Carte-clé

Vous devez utiliser java.awt.Dimension de votre clé.

Clé de Dimension = new Dimension(4, 12);

Dimension a une très belle hashCode() méthode qui produit un autre hashCode pour chaque paire de nombres entiers positifs, de sorte que les hashCodes (4, 12) et (12, 4) sont différentes. De sorte que ces sont rapides à instancier et de très bonnes hashCodes.

Je ne souhaite qu'ils avaient fait la classe immuable, mais vous pouvez faire votre propre immuable classe calquée sur la Dimension.

Voici un tableau montrant le hashCode pour différentes valeurs de la largeur et de la hauteur:

     0   1   2   3   4  <-- width
  +--------------------
0 |  0   2   5   9  14
1 |  1   4   8  13
2 |  3   7  12
3 |  6  11
4 | 10

^
|
height

Si vous suivez les hashCodes dans l'ordre de 0 à 14 ans, vous verrez le modèle.

Voici le code qui produit cette hashCode:

public int hashCode() {
    int sum = width + height;
    return sum * (sum + 1)/2 + width;
}

On peut reconnaître la formule pour les nombres triangulaires à l'intérieur de la dernière ligne. C'est pourquoi la première colonne du tableau contient tous les nombres triangulaires.

Pour la vitesse, vous devez calculer le hashCode dans le constructeur. Donc, l'ensemble de votre classe pourrait ressembler à ceci:

public class PairHash {
  private final int hash;
  public PairHash(int a, int b) {
    int sum = a+b;
    hash = sum * (sum+1)/2 + a;
  }
  public int hashCode() { return hash; }
}

Bien sûr, si vous aurez probablement besoin d'une méthode equals, mais vous vous limitez à des entiers positifs qui ne débordera pas, vous pouvez ajouter un très rapide:

public class PairHash {
  //PAIR_LIMIT is 23170
  //Keeping the inputs below this level prevents overflow, and guarantees
  //the hash will be unique for each pair of positive integers. This
  //lets you use the hashCode in the equals method.
  public static final int PAIR_LIMIT = (int) (Math.sqrt(Integer.MAX_VALUE))/2;
  private final int hash;

  public PairHash(int a, int b) {
    assert a >= 0;
    assert b >= 0;
    assert a < PAIR_LIMIT;
    assert b < PAIR_LIMIT;
    int sum = a + b;
    hash = sum * (sum + 1) / 2 + a;
  }

  public int hashCode() { return hash; }

  public boolean equals(Object other) {
    if (other instanceof PairHash){
      return hash == ((PairHash) other).hash;
    }
    return false;
  }
}

Nous restreindre à des valeurs positives, car les valeurs négatives produisent une certaine dupliqué des codes de hachage. Mais avec cette restriction en place, ce sont les plus rapides hashCode() et equals() les méthodes qui peuvent être écrits. (Bien sûr, vous pouvez écrire hashCodes tout aussi rapidement dans toute immuable de la classe par le calcul de la hashCode dans le constructeur.)

Si vous ne pouvez pas vivre avec ces restrictions, vous avez juste besoin de sauvegarder les paramètres.

public class PairHash {
  private final int a, b, hash;
  public PairHash(int a, int b) {
    this.a = a;
    this.b = b;
    int sum = a+b;
    hash = sum * (sum+1)/2 + a;
  }
  public int hashCode() { return hash; }
  public boolean equals(Object other) {
    if (other instanceof PairHash) {
      PairHash otherPair = (PairHash)other;
      return a == otherPair.a && b == otherPair.b;
    }
    return false;
}

Mais voici le kicker. Vous n'avez pas besoin de cette classe. Depuis la formule vous donne un entier unique pour chaque paire de nombres, vous pouvez l'utiliser Entier comme votre carte de clés. L'Entier de la classe a sa propre rapide equals() et hashCode méthodes qui fonctionnent bien. Cette méthode permettra de générer la clé de hachage à partir de deux valeurs courtes. La seule restriction est que les entrées doivent être positifs à court de valeurs. C'est la garantie de ne pas déborder, et en jetant l'intermédiaire somme pour un long, il a une gamme plus large que la méthode précédente: Il fonctionne avec tous les résultats positifs à court de valeurs.

static int hashKeyFromPair(short a, short b) {
  assert a >= 0;
  assert b >= 0;
  long sum = (long) a + (long) b;
  return (int) (sum * (sum + 1) / 2) + a;
}

OriginalL'auteur MiguelMunoz

Vous pouvez stocker deux entiers dans un long comme ça,

   long n = (l << 32) | (r & 0XFFFFFFFFL);

Ou vous pouvez utiliser la suite Pair<Integer, Integer> classe,

public class Pair<L, R> {

    private L l;
    private R r;

    public Pair() {
    }

    public Pair(L l, R r) {
        this.l = l;
        this.r = r;
    }

    public L getLeft() {
        return l;
    }

    public R getRight() {
        return r;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair obj = (Pair) o;
        return l.equals(obj.l) && r.equals(obj.r);
    }

    @Override
    public int hashCode() {
        return l.hashCode() ^ r.hashCode();
    }
} 

OriginalL'auteur ZZ Coder

Une autre approche serait d'utiliser imbriquée cartes:

Map<Integer,Map<Integer,Object>>

Ici, vous n'avez pas de frais généraux pour créer des clés. Cependant, vous avez plus de frais généraux pour créer et récupérer des entrées correctement et vous devez toujours à la carte-accès pour trouver l'objet que vous recherchez.

OriginalL'auteur Wolfgang

Vous avez besoin d'écrire le droit eqauls et hashcode méthodes , ou de produire certains bugs.

OriginalL'auteur Peter Lee