Comment créer un HashMap avec deux clés (paire de clés, valeur) ?

Question

J'ai un tableau d'entiers en 2D. Je veux qu'ils soient placés dans un HashMap. Mais je veux accéder aux éléments du HashMap en fonction de l'index du tableau. Quelque chose comme :

Pour A[2][5], map.get(2,5) qui renvoie une valeur associée à cette clé. Mais comment créer un hashMap avec une paire de clés ? Ou, en général, plusieurs clés : Map<((key1, key2,..,keyN), Value) de manière à ce que je puisse accéder à l'élément en utilisant get(key1,key2,...keyN).

EDIT : 3 ans après avoir posté la question, je veux y ajouter un peu plus de choses

Je suis tombé sur un autre moyen pour NxN matrix .

Indices de tableau, i y j peut être représenté comme un seul key de la manière suivante :

int key = i * N + j;
//map.put(key, a[i][j]); // queue.add(key); 

Et les indices peuvent être retraités à partir de l'indice key de cette façon :

int i = key / N;
int j = key % N;

Answer 1

Utilisez un Pair comme clés pour le HashMap . JDK n'a pas de Pair, mais vous pouvez soit utiliser une librairie tierce telle que http://commons.apache.org/lang ou écrivez votre propre histoire de couple.

Answer 2

Java 7+ contient une nouvelle Map.Entry<K,V> que vous pouvez utiliser comme clé pour votre carte (ou entrée pour votre ensemble). Java 9+ contient également une classe Map.entry(K k, V v) pour créer facilement de nouvelles Map.Entry objets.

Utilisation :

Map<Map.Entry<Integer,Integer>, Integer> map = new HashMap<>();
map.put(Map.entry(1, 2), 0);

Il existe également Pair<K, V> dans javafx.util

Map<Pair<Integer,Integer>, Integer> map = new HashMap<>();
map.put(new Pair(1, 2), 0);

Answer 3

Créez une classe de valeurs qui représentera votre clé composée, comme par exemple :

class Index2D {
  int first, second;

  // overrides equals and hashCode properly here
}

en prenant soin d'outrepasser equals() y hashCode() correctement. Si cela semble représenter beaucoup de travail, vous pouvez envisager d'utiliser des conteneurs génériques prêts à l'emploi, par exemple Pair fournis par apache commons entre autres.

Il existe également de nombreux questions similaires ici, avec d'autres idées, comme l'utilisation de Guava Tableau Il permet cependant aux clés d'avoir des types différents, ce qui pourrait être excessif (en termes d'utilisation de la mémoire et de complexité) dans votre cas, puisque je crois comprendre que vos clés sont toutes deux des entiers.

Answer 4

S'il s'agit de deux entiers, vous pouvez essayer un truc rapide et sale : Map<String, ?> en utilisant la clé comme i+"#"+j .

Si la clé i+"#"+j est la même chose que j+"#"+i essayez min(i,j)+"#"+max(i,j) .

Answer 5

Vous pourriez créer votre objet clé de la manière suivante :

public class MapKey {

public  Object key1;
public Object key2;

public Object getKey1() {
    return key1;
}

public void setKey1(Object key1) {
    this.key1 = key1;
}

public Object getKey2() {
    return key2;
}

public void setKey2(Object key2) {
    this.key2 = key2;
}

public boolean equals(Object keyObject){

    if(keyObject==null)
        return false;

    if (keyObject.getClass()!= MapKey.class)
        return false;

    MapKey key = (MapKey)keyObject;

    if(key.key1!=null && this.key1==null)
        return false;

    if(key.key2 !=null && this.key2==null)
        return false;

    if(this.key1==null && key.key1 !=null)
        return false;

    if(this.key2==null && key.key2 !=null)
        return false;

    if(this.key1==null && key.key1==null && this.key2 !=null && key.key2 !=null)
        return this.key2.equals(key.key2);

    if(this.key2==null && key.key2==null && this.key1 !=null && key.key1 !=null)
        return this.key1.equals(key.key1);

    return (this.key1.equals(key.key1) && this.key2.equals(key2));
}

public int hashCode(){
    int key1HashCode=key1.hashCode();
    int key2HashCode=key2.hashCode();
    return key1HashCode >> 3 + key2HashCode << 5;
}

}

L'avantage de ceci est : Vous serez toujours sûr de couvrir également tous les scénarios d'égaux.

NOTE : Votre clé1 et votre clé2 doivent être immuables. Ce n'est qu'à cette condition que vous serez en mesure de construire un objet clé stable.