Навіщо використовувати просте число в hashCode?

Мені було просто цікаво, чому в hashCode()методі класу використовуються праймери? Наприклад, при використанні Eclipse для створення мого hashCode()методу завжди використовується найпросте число 31:

public int hashCode() {
     final int prime = 31;
     //...
}

Список літератури:

Ось хороший буквар на Hashcode та стаття про те, як працює хеширование ( C #, але поняття можна передати): Керівництво Еріка Ліпперта та правила для GetHashCode ()

Тому що ви хочете, щоб число, на яке ви помножуєтесь, і кількість відер, які ви вставляєте, мати ортогональні прості множники.

Припустимо, у нього потрібно вставити 8 відер. Якщо число, яке ви використовуєте для множення, є деяким кратним 8, то відро, вставлене в нього, визначатиметься лише найменш значущим записом (тим, що не множиться взагалі). Подібні записи зіткнуться. Не добре для хеш-функції.

31 є достатньо великим прем'єр-мінімом, що кількість відра навряд чи буде поділена на нього (і насправді, сучасні реалізації Java HashMap утримують кількість відра до 2).

Прості номери вибираються для найкращого розподілу даних між хеш-відрами. Якщо розподіл входів випадковий і рівномірно розподілений, то вибір хеш-коду / модуля значення не має. Це має вплив лише тоді, коли на входах є певна схема.

Це часто трапляється при роботі з місцями пам'яті. Наприклад, усі 32-бітні цілі числа вирівнюються за адресами, розділеними на 4. Перегляньте таблицю нижче, щоб візуалізувати ефекти використання простого проти непрості модуля:

Input       Modulo 8    Modulo 7
0           0           0
4           4           4
8           0           1
12          4           5
16          0           2
20          4           6
24          0           3
28          4           0

Зауважте майже ідеальне розподіл, коли використовується простий модуль проти непростий модуль.

Однак, хоча вищенаведений приклад значною мірою надуманий, загальний принцип полягає в тому, що, маючи справу з шаблоном входів , використання модуля простого числа дасть найкращий розподіл.

Для чого це варто, Ефективна Java 2nd Edition відмовляється від питання математики і просто скаже, що причиною вибору 31 є:

• Тому що це дивна прем'єр-мінімум, і "традиційно" використовувати праймери
• Це також одна менша, ніж потужність дві, що дозволяє розрядити оптимізацію

Ось повна цитата з пункту 9: Завжди переосмислюйте, hashCodeколи ви перекриєтеequals :

Значення 31 було вибрано, тому що це незвичайний прайм. Якби це було парне, а множення переповнене, інформація втрачалася б, оскільки множення на 2 еквівалентно зміщенню. Перевага використання прайме менш зрозуміла, але це традиційно.

Приємною властивістю 31 є те, що множення можна замінити зсувом ( §15.19 ) та відніманням для кращої продуктивності:

 31 * i == (i << 5) - i

Сучасні віртуальні машини роблять подібну оптимізацію автоматично.

---

Хоча рецепт у цьому пункті дає досить хороші хеш-функції, він не дає найсучасніших хеш-функцій, а також бібліотеки платформи Java не надають таких хеш-функцій, як випуск 1.6. Написання таких хеш-функцій - тема дослідження, найкраще залишена математикам та теоретикам-комп’ютерам.

Можливо, наступний випуск платформи забезпечить сучасні хеш-функції для своїх класів та корисних методів, що дозволить середнім програмістам побудувати такі хеш-функції. Тим часом методи, описані в цьому пункті, повинні бути адекватними для більшості застосувань.

Скоріше спрощено, можна сказати, що використання множника з численними дільниками призведе до більшого хеш-зіткнення . Оскільки для ефективного хешування ми хочемо мінімізувати кількість зіткнень, ми намагаємось використовувати множник, який має менше дільників. Просте число за визначенням має рівно два чітких, позитивних дільника.

Пов'язані питання

• Java-хеш-код з одного поля - рецепт, а також приклад використання будівельників Apache Commons Lang
• чи неправильно визначати хеш-код об’єкта як суму, множення, будь-що, усіх хеш-кодів змінних класу?
• Абсолютний посібник для початківців щодо переміщення бітів?

Я чув, що 31 був обраний таким чином, щоб компілятор міг оптимізувати множення на ліворуч на 5 біт, а потім відняти значення.

Ось цитування трохи ближче до джерела.

Він зводиться до:

• 31 є простим, що зменшує зіткнення
• 31 дає хороший розподіл, с
• розумний компроміс у швидкості

Спочатку ви обчислюєте значення хеш-модуля 2 ^ 32 (розмір an int), тож ви хочете щось порівняно просте до 2 ^ 32 (відносно простий означає, що немає загальних дільників). Будь-яке непарне число зробило б для цього.

Тоді для даної хеш-таблиці індекс зазвичай обчислюється з хеш-значення по модулю розміру хеш-таблиці, тому ви хочете щось, що є відносно простим до розміру хеш-таблиці. Часто з цієї причини розміри хеш-таблиць вибирають як прості числа. У випадку з Java реалізація Sun гарантує, що розмір завжди є двома, так що і непарне число також буде достатньо. Існує також додаткове масаж хеш-клавіш для подальшого обмеження зіткнень.

Поганий ефект, якби хеш-таблиця та множник мали спільний фактор, nможуть полягати в тому, що за певних обставин використовуються лише 1 / n записів у хеш-таблиці.

Причина застосування простих чисел - мінімізація зіткнень, коли дані демонструють певні закономірності.

Спочатку спочатку: Якщо дані випадкові, тоді не потрібно простого числа, ви можете виконати операцію з модом проти будь-якого числа, і у вас буде однакова кількість зіткнень для кожного можливого значення модуля.

Але коли дані не випадкові, то трапляються дивні речі. Наприклад, розглянемо числові дані, які завжди кратні 10.

Якщо ми використовуємо mod 4, ми знаходимо:

10 мод 4 = 2

20 мод 4 = 0

30 мод 4 = 2

40 мод 4 = 0

50 мод 4 = 2

Тож із 3 можливих значень модуля (0,1,2,3) зіткнення мають лише 0 і 2, що погано.

Якщо ми будемо використовувати просте число типу 7:

10 мод 7 = 3

20 мод 7 = 6

30 мод 7 = 2

40 мод 7 = 4

50 мод 7 = 1

тощо

Ми також зауважимо, що 5 не є вдалим вибором, але 5 - це головна причина, тому що всі наші ключі кратні 5. Це означає, що ми повинні вибрати просте число, яке не ділить наші ключі, вибираючи велике просте число. зазвичай достатньо.

Тому помилка на стороні повторюваності причин, що використовуються простими числами, - це нейтралізувати дію шаблонів у клавішах на розподіл зіткнень хеш-функції.

31 також характерний для Java HashMap, який використовує int як тип даних хеша. Таким чином, максимальна ємність 2 ^ 32. Немає сенсу використовувати більші прайми Ферма чи Мерсенна.

Зазвичай це допомагає досягти більш рівномірного розповсюдження ваших даних між хеш-відрами, особливо для ключів із низькою ентропією.