@SuppressWarnings("all")
public class HashTableDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        HashTable hashTable = new HashTable(7);
        char ch = ' ';
        boolean flag = true;
        while(flag){
            System.out.println("l(list) 查看所有雇员信息");
            System.out.println("a(add) 添加雇员信息到链表");
            System.out.println("s(select) 根据id查找指定雇员");
            System.out.println("d(delet) 根据id删除指定雇员信息,并返回信息");
            System.out.println("D(delet) 根据id删除指定雇员信息");
            System.out.println("e(exit) 退出");
            System.out.println("=======================");
            ch = sc.next().charAt(0);
            switch(ch){
                case 's':
                    System.out.println("请输入需要查找的雇员id");
                    int id1 = sc.nextInt();
                    hashTable.findEmpById(id1);
                    break;
                case 'l':
                    hashTable.list();
                    break;
                case 'a':
                    System.out.println("请输入id");
                    int id = sc.nextInt();
                    System.out.println("请输入名称");
                    String name = sc.next();
                    Emp emp = new Emp(id,name);
                    hashTable.add(emp);
                    break;
                case 'd':
                    try{
                        System.out.println("请输入要删除的雇员id");
                        int id2 = sc.nextInt();
                        Emp emp1 = hashTable.delEmp(id2);
                        System.out.printf(">>>\tData:\t%s\n",emp1);
                    }catch(Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'D':
                    try {
                        System.out.println("请输入要删除的雇员id");
                        int vlaue = sc.nextInt();
                        hashTable.delEmp01(vlaue);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    sc.close();
                    flag = false;
                    break;
                default:
                    System.out.println("选择存在项");
                    break;
            }
        }
    }
}
@SuppressWarnings("all")
//创建HashTable管理多条链表
class HashTable{
    private EmpLinkedList[] empLinkedListArray;
    //表示共有多少条链表(链表的大小)
    private int size;
    //构造器，初始化链表
    public HashTable(int size) {
        //初始化size值
        this.size = size;
        //初始化数组大小
        empLinkedListArray = new EmpLinkedList[size];
        //TODO 注意: 每一个链表都需要初始化否则报错空指针异常
        for(int i = 0;i < size;i ++){
            empLinkedListArray[i] = new EmpLinkedList();
        }
    }

    //添加雇员
    public void add(Emp emp){
        //根据员工的id，得到该员工应当添加到哪条链表
        int num = hashFun(emp.id);
        //将emp添加到对应的链表中
        empLinkedListArray[num - 1].add(emp);
    }

    //遍历所有的链表(遍历HashTable)
    public void list(){
        for(int i = 0;i < size;i ++){
            empLinkedListArray[i].list(i);
        }
    }

    //编写散列函数，使用一个简单取模法
    public int hashFun(int id){
        return id % size;
    }

    //根据id查找雇员
    public void findEmpById(int id){
        int num = hashFun(id);
        Emp emp = empLinkedListArray[num - 1].findById(id);
        if(emp != null){
            System.out.printf("在第%d个链表中查找到 的雇员信息如下：\n>>> id: %d\n>>> name: %s",num,emp.id,emp.name+"\n");
        }else{
            System.out.println("抱歉>"+num+"<链表中没有找到任何信息");
        }
    }

    public Emp delEmp(int id){
        int num = hashFun(id);
        Emp del = empLinkedListArray[num - 1].del(id);
        return del;
    }


    public void delEmp01(int id){
        int num = hashFun(id);
        empLinkedListArray[num - 1].del01(id);
    }
}
@SuppressWarnings("all")
//表示一个雇员
class Emp{
    public int id;
    public String name;
    public Emp next;

    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'';
    }
}
@SuppressWarnings("all")
//表示链表
class EmpLinkedList{
    //头指针，执行第一个Emp，因此我们这个链表的head是直接指向第一个Emp
    private Emp head;

    /**
     * 添加雇员到链表
     * 说明：
     * 1.假设，当添加雇员时，id是自增长，即id的分配总是从小到大
     * 因此我们将该雇员直接加入到本链表的最后即可
     * @param emp
     */
    public void add(Emp emp){
        //如果是添加第一个雇员
        if(head == null){
            head = emp;
            return;
        }
        //如果不是第一个雇员，则使用一个辅助指针，帮助定位到最后
        Emp curEmp = head;
        while(true){
            //说明到链表最后
            if(curEmp.next == null)
                break;
            //指针后移
            curEmp = curEmp.next;
        }
        //退出时直接将tmp加入到链表即可
        curEmp.next = emp;
    }

    /**
     * 遍历链表的雇员信a
     */
    public void list(int no){
        if(head == null){
            System.out.println("第>"+(no + 1)+"<个链表为空");
            return;
        }
        System.out.println("*-==第>"+(no + 1)+"<个链表中的雇员的信息为==-*");
        Emp curEmp = head;
        while(true){
            System.out.printf(">>> id: %d \n>>> name: %s",curEmp.id,curEmp.name+"\n");
            //判断是否遍历到链表的最后
            if(curEmp.next == null)
                break;
            //指针后移
            curEmp = curEmp.next;
        }
    }

    //根据id查找雇员信息
    public Emp findById(int id){
        if(head == null){
            return null;
        }
        Emp curEmp = head;
        boolean flag = false;
        while(true){
            if(curEmp.id == id){
                flag = true;
                break;
            }
            if(curEmp.next == null){
                break;
            }
            curEmp = curEmp.next;
        }
        if(flag){
            return curEmp;
        }else{
            return null;
        }
    }

    //根据id删除雇员,并返回删除的雇员信息
    public Emp del(int id){
        if(head == null){
            throw new RuntimeException(">>>"+id+"<链表为空删除无效");
        }
        //赋值指针
        Emp curEmp = head;
        //记录上一个位置指针
        Emp pre = head;
        while(true){
            if(curEmp.id == id){
                break;
            }
            if(curEmp == null){
                curEmp = null;
                break;
            }
            //将当前节点赋值给pre
            pre = curEmp;
            //curEmp节点向后移动
            curEmp = curEmp.next;
        }
        //判断当前节点是否为null
        if(curEmp == null){
            return null;
        }
        //判断头节点是否和当前节点相同
        if(head == curEmp){
            //将curEmp.next元素赋值给头节点
            head = curEmp.next;
            return curEmp;
        }
        //将赋值的元素再赋值给pre的next
        pre.next = curEmp.next;
        return curEmp;
    }

    //根据id删除雇员
    public void del01(int id){
        if(head == null){
            throw new RuntimeException(">>>"+id+"<链表为空删除无效");
        }
        Emp curEmp = head;
        boolean flag = false;
        while(true){
            if(curEmp.id == id){
                flag = true;
                break;
            }
            if(curEmp == null){
                break;
            }
            curEmp = curEmp.next;
        }
        if(flag){
            System.out.println("该"+id+"雇员删除成功");
            //判断下一个next节点是否为null
            if(curEmp.next == null){
                //如果下一个next就是null那么就说明了这是第一个元素直接将头元素赋值为null即可
                head = null;
            }else{
                //否则将下一个元素赋值为null
                curEmp.next = null;
            }
        }else{
            System.out.println("您输入的雇员可能本来就不存在");
        }
    }
}