Object.hashCode(): примеры (JAVA)

Пример вывода:
-964404313

Python

# В Python встроен hash() и метод __hash__
class P:
    def __init__(self,x): self.x=x
    def __hash__(self):
        return hash(self.x)

p=P(10)
print(hash(p))

Пример вывода:
10

Объекты, для которых не определён __hash__ или которые изменяемы, могут быть не пригодны в качестве ключей.

SQL

-- SQL Server: HASHBYTES
SELECT HASHBYTES('SHA2_256', CONVERT(varbinary(MAX), 'text'));

Возвращает бинарный хеш, отличающийся от Java int и пригодный для криптографической проверки.

C#

// Object.GetHashCode() - аналог Java
class P { public int Id; public override int GetHashCode() => Id.GetHashCode(); }

Поведение и контракт близки к Java: при переопределении Equals требуется переопределять GetHashCode.

Lua

-- Таблицы в Lua хешируются по ссылке; tostring возвращает представление с адресом
local t = {}
print(tostring(t))

Пример вывода:
table: 0x7f9d9400a0

Go

// Нет универсального hashCode; для строк есть hashing по алгоритму в пакете hash/fnv
package main
import (
  "fmt"; "hash/fnv"
)
func main(){
  h:=fnv.New32a(); h.Write([]byte("abc")); fmt.Println(h.Sum32())
}

Пример вывода:
1335831723

Kotlin

// hashCode() у Kotlin аналогичен Java; data class генерирует equals и hashCode автоматически
data class D(val x:Int)
fun main(){ println(D(1).hashCode()) }

Пример вывода:
1

Отличие от Java: в некоторых языках хеш-функции направлены на криптографические задачи или возвращают бинарные строки; в JVM-подобных языках (Kotlin, Scala) контракт близок к Java.

1) Изменяемые поля в hashCode

Если объект используется как ключ в HashSet/HashMap, а поля, участвующие в вычислении хеша, изменяются после вставки, поиск и удаление могут перестать работать.

import java.util.HashSet;

class Item {
    int id;
    public Item(int id){this.id=id;}
    @Override public int hashCode(){ return id; }
    @Override public boolean equals(Object o){
        return (o instanceof Item) && ((Item)o).id==id;
    }
    public static void main(String[] args){
        HashSet s = new HashSet<>();
        Item it = new Item(1);
        s.add(it);
        System.out.println(s.contains(it));
        it.id = 2; // изменился хеш
        System.out.println(s.contains(it));
        s.remove(it);
        System.out.println(s.size());
    }
}

Вывод:
true
false
1

Объяснение: объект больше не находится в той же корзине, поэтому remove не удаляет его.

2) Переопределён equals, но не hashCode

import java.util.HashSet;
class P{
    int id; P(int id){this.id=id;}
    @Override public boolean equals(Object o){ return (o instanceof P) && ((P)o).id==id; }
}
public class T{ public static void main(String[] args){
    HashSet
 hs = new HashSet<>();
    hs.add(new P(1));
    hs.add(new P(1));
    System.out.println(hs.size());
}}

Вывод:
2

Объяснение: equals указывает равенство, но разные hashCode (наследуются от Object), поэтому HashSet допускает дубликаты.

3) Ожидание стабильности между запусками JVM

Значение Object.hashCode() по умолчанию не гарантирует одинаковость между процессами. Для распределённых систем нужно использовать детерминированные хеши (MD5, SHA, Murmur3) вместо hashCode().

• Сигнатура Object.hashCode() остаётся неизменной на протяжении многих версий Java.
• Появление вспомогательных утилит: Objects.hash() (Java 7) и улучшения в Arrays для хеширования массивов доступны давно и являются стандартной практикой.
• Записи (records) получили автоматически сгенерированные equals и hashCode начиная с Java 16, что упрощает корректную реализацию для классов-значений.
• В JVM могли происходить внутренние оптимизации реализации Object.hashCode(), но специфика контракта остаётся прежней.

1) Классическая схема комбинирования полей (множитель 31)

public class ComplexKey {
    int a; long b; String c;
    @Override public int hashCode(){
        int result = Integer.hashCode(a);
        result = 31 * result + Long.hashCode(b);
        result = 31 * result + (c == null ? 0 : c.hashCode());
        return result;
    }
}

Комментарий: 31 выбран за хорошие распределительные свойства и быстрые операции (умножение и суммирование).

2) Использование System.identityHashCode для отладки

public class IdentityDemo {
    public static void main(String[] args){
        String s1 = new String("x");
        String s2 = new String("x");
        System.out.println(s1.hashCode()); // значение от содержимого
        System.out.println(s2.hashCode());
        System.out.println(System.identityHashCode(s1));
        System.out.println(System.identityHashCode(s2));
    }
}

Вывод (пример):
120
120
2018699554
1311053135

Комментарий: identityHashCode показывает различие по адресу независимо от equals/hashCode строки.

3) Стратегии для распределённых систем

// Для устойчивого распределения используется крипто- или не крипто-хеш
import java.security.MessageDigest;
import java.util.Base64;

public class StableHash {
    public static String sha256(String s) throws Exception{
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] d = md.digest(s.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(d);
    }
    public static void main(String[] args) throws Exception{
        System.out.println(sha256("key1"));
    }
}

Пример вывода:
XUFAKrxLKna5cZ2REBfFkg==... (длинная base64-строка)

Комментарий: такой хеш детерминирован и одинаков между запусками и платформами, но не совместим с Java hashCode.

4) Использование сторонних библиотек (MurmurHash, Guava)

// Пример идеи: Guava Hashing.murmur3_32().hashUnencodedChars("text").asInt();
// даёт стабильный 32-битный хеш с хорошим распределением

Комментарий: полезно для распределённых кэшей и шардирования, лучше чем простые комбинации полей.

5) Хеширование больших структур и потоковых данных

// Для больших объектов рекомендуется использовать потоковое вычисление хеша (MessageDigest)
// вместо вычисления большого временного объекта в памяти.

Комментарий: экономия памяти и согласованность результатов важны для больших данных.

6) Хеширование для mutable keys - копия immutable snapshot

// Если ключи изменяемы, хранится их иммутабельная копия состояния для ключа
// или хеш вычисляется по snapshot-полям при вставке в карту.

Комментарий: это предотвращает проблемы с поиском и удалением при изменении полей ключа.