Comment faire fonctionner HashMap avec Arrays comme clé?

Vous ne pouvez pas le faire de cette façon. Les deux t et a différentes qui ont hashCode() valeurs car le java.lang.Array.hashCode() méthode est héritée de Objectqui utilise la référence pour calculer le hash-code (par défaut la mise en œuvre). Donc le code de hachage pour les tableaux de référence-dépendants, ce qui signifie que vous aurez un autre hash-code de la valeur pour t et a. En outre, equals ne fonctionnera pas pour les deux tableaux, car c'est également basé sur la référence.

La seule façon que vous pouvez faire c'est de créer une classe personnalisée qui tient le boolean tableau comme un membre interne. Ensuite, vous avez besoin de remplacer equals et hashCode de telle sorte à ce que les instances qui contiennent des tableaux avec des valeurs identiques sont égaux et ont le même hash-code.

Une option plus simple serait d'utiliser List<Boolean> comme la clé. Par la la documentation la hashCode() mise en œuvre pour List est défini comme:

int hashCode = 1;
Iterator<E> i = list.iterator();
while (i.hasNext()) {
    E obj = i.next();
    hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
}

Comme vous pouvez le voir, il dépend des valeurs à l'intérieur de votre liste et de ne pas la référence, et donc, cela devrait fonctionner pour vous.

Map implémentations s'appuie sur la touche equals et hashCode méthodes. Les tableaux en java sont directement s'étend de Objectils utilisent par défaut equals et hashCode de Object qui compare uniquement identity.

Si j'étais vous, je voudrais créer une classe Key

class Key {
    private final boolean flag1;
    private final boolean flag2;

    public Key(boolean flag1, boolean flag2) {
        this.flag1 = flag1;
        this.flag2 = flag2;
    }

    @Override
    public boolean equals(Object object) {
        if (!(object instanceof Key)) {
            return false;
        }

        Key otherKey = (Key) object;
        return this.flag1 == otherKey.flag1 && this.flag2 == otherKey.flag2;
    }

    @Override
    public int hashCode() {
        int result = 17; //any prime number
        result = 31 * result + Boolean.valueOf(this.flag1).hashCode();
        result = 31 * result + Boolean.valueOf(this.flag2).hashCode();
        return result;
    }
}

Après cela, vous pouvez utiliser votre clé avec Map:

Map<Key, Integer> map = new HashMap<>();

Key firstKey = new Key(false, false);
map.put(firstKey, 1);

Key secondKey = new Key(false, false) //same key, different instance
int result = map.get(secondKey); //--> result will be 1

De référence:
Java code de hachage d'un champ

boolean[] t;
t = a;

Si vous donnez à cela, au lieu de boolean[] t = {false, false};alors vous obtiendrez le résultat souhaité.

C'est parce que le Map magasins de la reference comme le keyet dans votre cas, si t a les mêmes valeurs, il n'a pas la même référence que a.

Par conséquent, lorsque vous donnez t=aça marchera.

Son très similaire à cela:-

String a = "ab";
String b = new String("ab");

System.out.println(a==b); //This will give false.

Les deux a & b contenir la même valeur, mais ont des références différentes. Par conséquent, lorsque vous essayez de comparer la référence à l'aide ==il donne false.

Mais si vous donnez, a = b; et puis essayer de comparer les referencevous aurez true.

Carte utilise equals() pour tester si vos clés sont les mêmes.

L'implémentation par défaut de cette méthode dans Object tests ==c'est à dire la référence à l'égalité. Donc, comme vos deux tableaux ne sont pas de la même matrice, equals renvoie toujours false.

Vous avez besoin de faire la carte d'appel Arrays.equals sur les deux tableaux pour vérifier l'égalité.

Vous pouvez créer un tableau de classe wrapper qui utilise Arrays.equals et puis cela va fonctionner comme prévu:

public static final class ArrayHolder<T> {

    private final T[] t;

    public ArrayHolder(T[] t) {
        this.t = t;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 23 * hash + Arrays.hashCode(this.t);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final ArrayHolder<T> other = (ArrayHolder<T>) obj;
        if (!Arrays.equals(this.t, other.t)) {
            return false;
        }
        return true;
    }
}

public static void main(String[] args) {
    final Map<ArrayHolder<Boolean>, Integer> myMap = new HashMap<>();

    myMap.put(new ArrayHolder<>(new Boolean[]{true, true}), 7);
    System.out.println(myMap.get(new ArrayHolder<>(new Boolean[]{true, true})));
}

Cela devrait fonctionner pour des matrices de tout type:

class ArrayHolder<T> {
    private final T[] array;
    @SafeVarargs
    ArrayHolder(T... ts) { array = ts; }
    @Override public int hashCode() { return Arrays.hashCode(array); }
    @Override public boolean equals(Object other) {
        if (array == other) { return true; }
        if (! (other instanceof ArrayHolder) ) {
            return false;
        }
        //noinspection unchecked
        return Arrays.equals(array, ((ArrayHolder) other).array);
    }
}

Ici est votre exemple converti pour utiliser ArrayHolder:

//boolean[] a = {false, false};
ArrayHolder<Boolean> a = new ArrayHolder<>(false, false);

//h = new HashMap<boolean[], Integer>();
Map<ArrayHolder<Boolean>, Integer> h = new HashMap<>();

h.put(a, 1);

//if(h.containsKey(a)) System.out.println("Found a");
assertTrue(h.containsKey(a));

//boolean[] t = {false, false};
ArrayHolder<Boolean> t = new ArrayHolder<>(false, false);

//if(h.containsKey(t)) System.out.println("Found t");
assertTrue(h.containsKey(t));

assertFalse(h.containsKey(new ArrayHolder<>(true, false)));

J'ai utilisé Java 8, mais je pense que Java 7 a tout ce dont vous avez besoin pour cela. J'ai testé hashCode et equals l'aide de TestUtils.

Une autre pensée est Joshua Bloch de l'Article 25: "Préférez les listes de tableaux."