Question

How is this possible:
HashMap<byte[], byte[]> and what is hash() of byte[]?

Answer 1

Yes, it is possible (with a big caveat, see below), but byte[] is not an “intrinsic type”. First, there’s no such thing, you probably mean a “primitive type”. Second: byte[] is not a primitive type, byte is. An array is always a reference type.

Arrays don’t have specific hashCode implementations, so they’ll just use the hashCode of Object, which means that the hashCode will be the indentity-hashCode, which is independent from the actual content.

In other words: a byte[] is a very bad Map key, because you can only retrieve the value with the exact same instance.

If you need a content-based hashCode() based on an array, you can use Arrays.hashCode(), but that won’t help you (directly) with the Map. There’s also Arrays.equals() to check for content equality.

You could wrap your byte[] in a thin wrapper object that implements hashCode() and equals() (using the methods mentioned above):

import java.util.Arrays;

public final class ArrayWrapper {
  private final byte[] data;
  private final int hash;

  public ArrayWrapper(final byte[] data) {
    // strictly speaking we should make a defensive copy here,
    // but I *assume* (and should document) that the argument
    // passed in here should not be changed
    this.data = data;
    this.hash = Arrays.hashCode(data);
  }

  @Override
  public int hashCode() {
    return hash
  }

  @Override
  public boolean equals(Object o) {
    if (!(o instanceof ArrayWrapper)) {
      return false;
    }
    ArrayWrapper other = (ArrayWrapper) o;
    return this.hash == other.hash && Arrays.equals(this.data, other.data);
  }
  // don't add getData to prevent having to do a defensive copy of data
}

Using this class you can then use a Map<ArrayWrapper,byte[]>.