实现了crud功能，其中delete功能是自己独立写的

    1. package com.atguigu.hashtable;
    3. import java.util.Scanner;
    5. /**
    6.  * 哈希表
    7.  * 谷歌面试题
    8.  *
    9.  * @author Dxkstart
    10.  * @create 2021-10-15-19:27
    11.  */
    12. public class HashTableDemo {
    13.     public static void main(String[] args) {
    15.         //创建哈希表
    16.         HashTable hashTable = new HashTable(7);
    18.         //写一个简单的菜单
    19.         Scanner scanner = new Scanner(System.in);
    20.         String key;
    22.         L:
    23.         while (true) {
    24.             System.out.println("~~~欢迎使用HashTable~~~");
    25.             System.out.println("1.添加员工信息");
    26.             System.out.println("2.删除员工信息");
    27.             System.out.println("3.显示所有员工信息");
    28.             System.out.println("4.根据id号查找员工信息");
    29.             System.out.println("5.退出程序");
    30.             key = scanner.next();
    32.             switch (key) {
    33.                 case "1":
    34.                     System.out.println("请输员工信息");
    35.                     System.out.println("id:");
    36.                     int id = scanner.nextInt();
    37.                     System.out.println("名字：");
    38.                     String name = scanner.next();
    39.                     hashTable.add(new Emp(id, name));
    40.                     break;
    41.                 case "2":
    42.                     System.out.println("请输要删除的员工的id");
    43.                     id = scanner.nextInt();
    44.                     hashTable.delete(id);
    45.                     break;
    46.                 case "3":
    47.                     hashTable.list();
    48.                     break;
    49.                 case "4":
    50.                     System.out.println("请输要查找的员工的id");
    51.                     id = scanner.nextInt();
    52.                     hashTable.findEmpById(id);
    53.                     break;
    54.                 case "5":
    55.                     scanner.close();
    56.                     break L;
    57.             }
    58.         }
    60.     }
    61. }
    63. //创建HashTable 管理多条链表
    64. class HashTable {
    65.     private EmpLinkedList[] empLinkedListsArray;
    66.     private int size;//表示有多少条链表
    68.     //构造器
    69.     public HashTable(int size) {
    70.         this.size = size;
    71.         //初始化empLinkedListsArray
    72.         empLinkedListsArray = new EmpLinkedList[size];
    73.         //?小心这里有坑，这是不要忘了分别初始化每一条链表！！！
    74.         for (int i = 0; i < size; i++) {
    75.             empLinkedListsArray[i] = new EmpLinkedList();
    76.         }
    77.     }
    79.     //添加员工
    80.     public void add(Emp emp) {
    81.         //根据员工的id，得到该员工应当添加到哪条链表
    82.         int empLinkedListNo = hashFun(emp.id);
    83.         //将emp添加到对应的链表中
    84.         empLinkedListsArray[empLinkedListNo].add(emp);
    86.     }
    88.     //遍历员工(遍历所有的链表,即哈希表)
    89.     public void list() {
    90.         for (int i = 0; i < size; i++) {
    91.             empLinkedListsArray[i].list(i);
    92.         }
    93.     }
    95.     //根据输入的id，查找员工信息
    96.     public void findEmpById(int id) {
    97.         //根据员工的id，得到该员工应当添加到哪条链表
    98.         int empLinkedListNo = hashFun(id);
    99.         Emp emp = empLinkedListsArray[empLinkedListNo].findEmpById(id);
    100.         if (emp != null) {
    101.             System.out.printf("在第%d条链表中找到员工 id = %d , 名字：%s \n", (empLinkedListNo + 1), id, emp.name);
    102.         } else {
    103.             System.out.println("没有找到该员工信息");
    104.         }
    105.     }
    107.     //删除员工
    108.     public void delete(int id) {
    109.         //根据员工的id，得到该员工在哪条链表
    110.         int empLinkedListNo = hashFun(id);
    111.         //删除对应的员工
    112.         empLinkedListsArray[empLinkedListNo].delete(id);
    113.     }
    115.     //编写一个散列函数，使用一个简单的取模法
    116.     //说明：
    117.     //这个HashTable中是一个数组，每个数组有一条链表，
    118.     //加入员工时，要确定这个员工加入到哪条链表中去
    119.     //即：要确定的是数组的角标
    120.     public int hashFun(int id) {
    121.         return id % size;
    122.     }
    124. }
    127. //表示一个雇员
    128. class Emp {
    129.     public int id;
    130.     public String name;
    131.     public Emp next;//next 默认为null
    133.     public Emp(int id, String name) {
    134.         this.id = id;
    135.         this.name = name;
    136.     }
    137. }
    139. //创建EmpLinkedList，表示链表
    140. class EmpLinkedList {
    141.     //头指针，指向第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
    142.     private Emp head;//默认null
    144.     //添加员工到链表
    145.     //说明：
    146.     //1.假定，当添加雇员时，id 是自增长的，即id的分配总是从小到大
    147.     // 因此我们将该雇员直接加入到本链表的最后即可
    148.     public void add(Emp emp) {
    149.         //如果是添加第一个员工
    150.         if (head == null) {
    151.             head = emp;
    152.             return;
    153.         }
    154.         //如果不是第一个员工，则使用一个辅助的指针，帮助定位到最后
    155.         Emp curEmp = head;
    156.         while (true) {
    157.             if (curEmp.next == null) {//说明到链表的最后
    158.                 break;
    159.             }
    160.             curEmp = curEmp.next;//往后移
    161.         }
    162.         //退出循环时，即指针指向了链表的最后
    163.         //将emp(员工信息)，连接到链表尾部
    164.         curEmp.next = emp;
    165.     }
    168.     //遍历链表信息
    169.     public void list(int no) {
    170.         if (head == null) {//说明链表为空
    171.             System.out.println("第" + (no + 1) + "条链表为空！");
    172.             return;
    173.         }
    174.         System.out.println("第" + (no + 1) + "条链表的信息为：");
    175.         Emp curEmp = head;//辅助指针
    177.         while (true) {
    178.             System.out.printf("  => id = %d,  name = %s \n", curEmp.id, curEmp.name);
    179.             if (curEmp.next == null) {//说明到链表的最后
    180.                 break;
    181.             }
    182.             curEmp = curEmp.next;//后移遍历
    183.         }
    184.     }
    186.     //根据id，查找员工信息
    187.     //如果找到，就返回Emp，如果没有找到，就返回null
    188.     public Emp findEmpById(int id) {
    189.         //判断链表是否为空
    190.         if (head == null) {
    191.             System.out.println("链表为空");
    192.             return null;
    193.         }
    195.         //辅助指针
    196.         Emp curEmp = head;
    197.         while (true) {
    198.             if (curEmp.id == id) {
    199.                 break;//这是curEmp就指向要查找的员工
    200.             }
    201.             //退出循环的条件
    202.             if (curEmp.next == null) {//说明当前链表没有找到该雇员
    203.                 curEmp = null;
    204.                 break;
    205.             }
    207.             curEmp = curEmp.next;//后移指针
    208.         }
    209.         return curEmp;
    211.     }
    214.     //删除链表信息（自己写的）
    215.     public void delete(int id) {
    216.         if (head == null) {//说明链表为空
    217.             System.out.println("当前链表为空");
    218.             return;
    219.         }
    220.         Emp curEmp = head;//辅助指针
    221.         if (curEmp.next == null && curEmp.id == id) {//只有一个员工
    222.             head = null;
    223.             System.out.println("删除成功1");
    224.             return;
    225.         }
    227.         while (true) {//将辅助指针指向要删除的节点的上一个节点
    228.             if (curEmp.next == null) {//说明到链表的最后
    229.                 System.out.println("没有此员工信息");
    230.                 return;
    231.             }
    232.             if (curEmp.next.id == id) {
    233.                 break;
    234.             }
    235.             curEmp = curEmp.next;//后移遍历
    236.         }
    238.         if (curEmp.next.next == null) {//如果此节点是链表上的最后一个节点
    239.             curEmp.next = null;
    240.             System.out.println("删除成功end");
    241.             return;
    242.         }
    243.         curEmp.next = curEmp.next.next;
    244.         System.out.println("删除成功");
    246.     }
    249. }