哈希算法，通过哈希函数得到一个值，只要key一样，value肯定会一样，但是哈希函数拟合的好，可以极大降低数据查找时间。

简单的实现，取模函数实现哈希表

增

 //插入操作

    public void insert(E key) {
   
        int index = hash(key);
        Node<E> head = TABLE[index];
        Node<E> node = new Node<E>(key);
        node.next = head.next;
        head.next = node;
    }

查

 //查找操作

    public boolean contains(E key){
   
        int index = hash(key);
        Node<E> node = TABLE[index].next;
        while (node != null){
   
            if (node.data.equals(key)){
   
                return true;
            }
            node = node.next;
        }
        return false;
    }

解决哈希冲突，就是多个数据占用一个位置，这里用链表将其连接起来

//初始化每一个头节点，用链表解决哈希冲突

    public HashTable(){
   
        for (int i = 0; i < TABLE_SIZE; i++) {
   
            TABLE[i] = new Node<>(null);
        }
    }

 private static class Node<E>{
   
        private final  E data;
        private Node<E> next;

        private Node(E data){
   
            this.data = data;
        }
    }

总览

package com.collection;

import org.w3c.dom.Node;

import java.util.Arrays;

/**
 * @author WangYH
 * @version 2021.1.3
 * @date 2023/4/30 16:06
 */

public class HashTable<E> {
   

    private final int TABLE_SIZE = 10;
    private final Node<E>[] TABLE = new Node[TABLE_SIZE];

    //初始化每一个头节点，用链表解决哈希冲突

    public HashTable(){
   
        for (int i = 0; i < TABLE_SIZE; i++) {
   
            TABLE[i] = new Node<>(null);
        }
    }

    //插入操作

    public void insert(E key) {
   
        int index = hash(key);
        Node<E> head = TABLE[index];
        Node<E> node = new Node<E>(key);
        node.next = head.next;
        head.next = node;
    }

    //查找操作

    public boolean contains(E key){
   
        int index = hash(key);
        Node<E> node = TABLE[index].next;
        while (node != null){
   
            if (node.data.equals(key)){
   
                return true;
            }
            node = node.next;
        }
        return false;
    }

    private int hash(E key) {
   
        int hashCode = key.hashCode();
        return hashCode % TABLE_SIZE;
    }

    //出现哈希冲突

    private static class Node<E>{
   
        private final  E data;
        private Node<E> next;

        private Node(E data){
   
            this.data = data;
        }
    }


    @Override
    public String toString() {
   
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < TABLE_SIZE; i++) {
   
            Node<E> head = TABLE[i].next;
            while (head != null) {
   
                builder.append(head.data).append(" -> ");
                head = head.next;
            }
            builder.append("\n");
        }
        return builder.toString();
    }
}

测试

package com.collection;

/**
 * @author WangYH
 * @version 2021.1.3
 * @date 2023/4/29 21:42
 */

public class Main {
   
    public static void main(String[] args) {
   
       HashTable<Integer> table = new HashTable<>();
       for (int i = 0;i < 100;i++){
   
           table.insert(i);
       }
        System.out.println(table);
    }
}