20-12-24 构建Hash表去储存员工信息

在本例中，体现了面向对象的思想，分别创建了三个类：

1. 哈希表一个类及其对应方法
2. 员工信息一个类，有链表结构
3. 头指针一个类，有链表的操作方法

package hashtable;

import java.util.Scanner;

public class HashTable {
    public static void main(String[] args) {
        MyFirstHashTable myFirstHashTable = new MyFirstHashTable(7);
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("add:  添加雇员");
            System.out.println("list: 显示雇员");
            System.out.println("find: 查找雇员");
            System.out.println("exit: 退出系统");

            key = scanner.next();
            switch (key) {
                case "add":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    //创建 雇员
                    Emp emp = new Emp(id, name);
                    myFirstHashTable.add(emp);
                    break;
                case "list":
                    myFirstHashTable.list();
                    break;
                case "find":
                    System.out.println("请输入要查找的id");
                    id = scanner.nextInt();
                    myFirstHashTable.findById(id);
                    break;
                case "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }
    }


}

//这个类是员工类
class Emp {
    public int id;
    private 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 + '\'' +
                '}';
    }
}

//这个类是hash表，就是存放头指针的类（用于操作哈希表）
class MyFirstHashTable {   //在添加的元素的时候，是直接根据HashTable去加的，而不是去操作EmpLinkedList对应的头指针
    private EmpLinkedList[] empLinkedListsArray;//一个存放类的数组
    int size;

    public MyFirstHashTable(int size) {
        this.size = size;    // 这句话要写的，因为后面的方法里面需要用到，
        empLinkedListsArray = new EmpLinkedList[size];
        for (int i = 0; i < size; i++) {
            empLinkedListsArray[i] = new EmpLinkedList();
        }
    }
    //这里还不能直接用!
    //因为这里虽然创建了数组，但是数组里面的以对象为基础的元素没有初始化！所以这里需要初始化每一个数组里面的元素
    //而且应该放在构造器里面，放在外面不能用啥意思啊？因为size是属性，只有通过实例或者类才可以调用属性


    //这里的函数名add是MyFirstHashTable数组的add方法，然后具体到某个元素之后是EmpLinkedList的方法(用于储存员工信息)
    public void add(Emp emp) {
        empLinkedListsArray[hashFun(emp)].add(emp);
    }

    public int hashFun(Emp emp) {
        return emp.id % size;   //最简单的Hash方法，这样可以取到所有的size值
    }

    public int hashFun(int id) {
        return id % size;
    }

    public void list() {
        for (int i = 0; i < size; i++) {
            empLinkedListsArray[i].list();
        }
    }

    public void findById(int id) {
        //在本类中方法可以直接调用
        Emp emp = empLinkedListsArray[hashFun(id)].findById(id);
        System.out.println("找到了对应的员工" + emp);
    }
}

//这个类是一个链表类（用于操作链表）
class EmpLinkedList {
    private Emp head;//创建一个指向Emp类的引用变量，存储在EmpLinkedList中
    Emp curEmp;    //注意，这里不应该直接使用head去操作，因为head会丢失，就找不到了。应该找一个临时变量。9

    //添加员工时，加到链表的最后
    public void add(Emp emp) {
        if (head == null) {//这里写错了！ 如果是头结点就应该加上现在的值！
            head = emp;
            return;
        }
        curEmp = head;
        while (curEmp.next != null) {
            curEmp = curEmp.next;
        }
        curEmp.next = emp;
        return;
    }

    public void list() {
        Emp curEmp = head;
        if (curEmp == null) {
            System.out.println("当前链表为空");
            return;
        }
        while (true) {
            System.out.println(curEmp);  //先做输出，再做判断，就可以保证最后一个员工的信息得到输出
            if (curEmp.next == null) {
                break;
            }
            curEmp = curEmp.next;
        }
    }

    public Emp findById(int id) {
        if (head == null) {
            System.out.println("该指针为空指针");
        }
        Emp curEmp = head;
        while (curEmp != null) {
            if (curEmp.id == id) {
                System.out.println();
                break;
            }
            if (curEmp == null) {
                break;
            }
            curEmp = curEmp.next;
        }
        return curEmp;
    }
}