散列表，也叫哈希表，是根据关键码和值 (key和value) 直接进行访问的数据结构，通过key和value来映射到集合中的一个位置，这样就可以很快找到集合中的对应元素
    哈希表 - 图1

    1. /**
    2.  * 哈希表
    3.  */
    4. public class HashTable {
    6.     /**
    7.      * 链表数组
    8.      */
    9.     private LinkedList[] linkedList;
    11.     /**
    12.      * 默认大小
    13.      */
    14.     private int size = 10;
    16.     public HashTable() {
    17.         this.linkedList = new LinkedList[size];
    18.         for(int i = 0; i< this.linkedList.length; i++) {
    19.             this.linkedList[i] = new LinkedList();
    20.         }
    21.     }
    23.     /**
    24.      * 哈希函数
    25.      * @return
    26.      */
    27.     private int getHash(Integer id) {
    28.         return id % 10;
    29.     }
    31.     /**
    32.      * 添加元素
    33.      * @param node
    34.      */
    35.     public void add(Node node) {
    36.         // 获取对应的索引
    37.         int hash = getHash(node.getId());
    38.         linkedList[hash].add(node);
    39.     }
    41.     /**
    42.      * 获取元素
    43.      */
    44.     public Node get(Integer id) {
    45.         // 获取对应的索引
    46.         int hash = getHash(id);
    47.         return linkedList[hash].get(id);
    48.     }
    50.     /**
    51.      * 打印所有元素
    52.      */
    53.     public void list() {
    54.         for(int i = 0; i< this.linkedList.length; i++) {
    55.             System.out.println("第" + i + "号链表");
    56.             this.linkedList[i].list();
    57.         }
    58.     }
    60.     public static void main(String[] args) {
    61.         HashTable hashTable = new HashTable();
    62.         Scanner scanner = new Scanner(System.in);
    63.         boolean loop = true;
    64.         while (loop) {
    65.             System.out.print("【哈希表】添加(1)、查找(2)、打印(3)、退出(0)：");
    66.             Integer key = scanner.nextInt();
    67.             switch (key) {
    68.                 case 1:
    69.                     System.out.print("Id：");
    70.                     int id = scanner.nextInt();
    71.                     System.out.print("Name：");
    72.                     String name = scanner.next();
    73.                     Node node = new Node(id, name);
    74.                     hashTable.add(node);
    75.                     break;
    76.                 case 2:
    77.                     System.out.print("查找的Id：");
    78.                     int id2 = scanner.nextInt();
    79.                     Node node2 = hashTable.get(id2);
    80.                     System.out.println(node2);
    81.                     break;
    82.                 case 3: hashTable.list(); break;
    83.                 case 0:
    84.                     scanner.close();
    85.                     loop = false;
    86.                     break;
    87.                 default: break;
    88.             }
    89.         }
    90.         System.out.println("程序退出。。。");
    91.     }
    93. }