Why can't a byte array (byte[]) be used as a key in a…

When using byte[] as a key in a HashMap, the standard implementations of hashCode() and equals() methods for arrays (Object.hashCode() and Object.equals()) compare object references, not their contents.

Object.hashCode() returns a hash code based on the memory address. Two arrays with the same content but located at different memory addresses will have different hash codes.
Object.equals(Object obj) returns true only if the references point to the same array object. Two different byte[] objects with the same content will be considered unequal.

Therefore, if you put a byte array as a key in a HashMap and then try to retrieve a value using another byte array with the same content, the HashMap will not find the corresponding entry because the hash codes will differ and equals will return false.

To use the content of a byte array as a key, a custom implementation is required that correctly computes the hash code and compares arrays based on their contents. For example, you can wrap byte[] in a class with overridden hashCode() and equals(), or use existing classes such as ByteBuffer.wrap() or adapters from libraries like Apache Commons ByteArrayUtils.hashCode() and Arrays.equals().

Example of problematic behavior:

byte[] key1 = {1, 2, 3};
byte[] key2 = {1, 2, 3};

Map<byte[], String> map = new HashMap<>();
map.put(key1, "value1");

System.out.println(map.containsKey(key2)); // false - despite having the same content

Example of a solution with a custom wrapper class:

import java.util.Arrays;

class ByteArrayWrapper {
    private final byte[] data;

    public ByteArrayWrapper(byte[] data) {
        this.data = data;
    }

    public byte[] getData() {
        return data;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ByteArrayWrapper that = (ByteArrayWrapper) o;
        return Arrays.equals(data, that.data); // Compare by content
    }

    @Override
    public int hashCode() {
        return Arrays.hashCode(data); // Hash code based on content
    }
}

Then, ByteArrayWrapper can be used as a key:

import java.util.HashMap;
import java.util.Map;

// Assuming ByteArrayWrapper class is defined above

byte[] key1Bytes = {1, 2, 3};
byte[] key2Bytes = {1, 2, 3}; // Another array instance

ByteArrayWrapper key1 = new ByteArrayWrapper(key1Bytes);
ByteArrayWrapper key2 = new ByteArrayWrapper(key2Bytes);

Map<ByteArrayWrapper, String> map = new HashMap<>();
map.put(key1, "value1");

System.out.println(map.containsKey(key2)); // true - now it works correctly

Why can't a byte array (byte[]) be used as a key in a HashMap?