在程式中，存放指定的資料最常用的資料結構有兩種：陣列和連結串列。

      陣列和連結串列的區別：

      1、陣列是將元素在記憶體中連續存放。

           連結串列中的元素在記憶體中不是順序儲存的，而是通過存在元素中的指標聯絡到一起。

      2、陣列必須事先定義固定的長度，不能適應資料動態地增減的情況。當資料增加時，可能超出原先定義的元素個數；當資料減少時，造成記憶體浪費。

           連結串列動態地進行儲存分配，可以適應資料動態地增減的情況。

      3、(靜態)陣列從棧中分配空間, 對於程式設計師方便快速,但是自由度小。

     連結串列從堆中分配空間, 自由度大但是申請管理比較麻煩。

陣列和連結串列在儲存資料方面到底孰優孰劣呢？根據陣列和連結串列的特性，分兩類情況討論。

一、當進行資料查詢時，陣列可以直接通過下標迅速訪問陣列中的元素。而連結串列則需要從第一個元素開始一直找到需要的元素位置，顯然，陣列的查詢效率會比連結串列的高。

二、當進行增加或刪除元素時，在陣列中增加一個元素，需要移動大量元 素，在記憶體中空出一個元素的空間，然後將要增加的元素放在其中。同樣，如果想刪除一個元素，需要移動大量元素去填掉被移動的元素。而連結串列只需改動元素中的指標即可實現增加或刪除元素。

那麼，我們開始思考：有什麼方式既能夠具備陣列的快速查詢的優點又能融合連結串列方便快捷的增加刪除元素的優勢？HASH呼之欲出。

所謂的hash，簡單的說就是雜湊，即將輸入的資料通過hash函式得到一個key值，輸入的資料儲存到陣列中下標為key值的陣列單元中去。

我們發現，不相同的資料通過hash函式得到相同的key值。這時候，就產生了hash衝突。解決hash衝突的方式有兩種。一種是掛鏈式，也叫拉鍊法。掛鏈式的思想在產生衝突的hash地址指向一個連結串列，將具有相同的key值的資料存放到連結串列中。另一種是建立一個公共溢位區。將所有產生衝突的資料都存放到公共溢位區，也可以使問題解決。

如何實現hash的動態增加空間的效果？這和裝在因子密切相關。裝填因子 = 填入表中的元素個數 / 散列表的長度。當裝填因子達到一定值a時，我們就讓陣列增加一定的記憶體空間，同時rehash。

下面用兩個示例來加深理解。

示例一：用連結串列實現佇列

節點類

1. package cn.netjava.hash;  
2. public class LinkNode {  
3.     //構造器：傳入Object物件  
4.     public LinkNode(Object obj){  
5.         data=obj;  
6.     }  
7.     public Object data; //Object物件  
8.     public LinkNode next;//下一個節點  
9.         //重寫toString方法  
10.     public String toString(){  
11.         //System.out.println(data);  
12.         return (String)data;  
13.     }  
14.        //返回Object物件  
15.     public Object getData(){  
16.         return data;  
17.     }  
18.         //修改Onject物件  
19.     public Object Update(Object o){  
20.         data=o;  
21.         return o;  
22.     }  
23. }  

佇列類

1. package cn.netjava.hash;  
2. public class LinkQueue {  
3.     public LinkNode front=null;//第一個節點  
4.     public LinkNode last=null;//最後一個節點  
5.     public static void main(String args[]){  
6.         LinkQueue lq=new LinkQueue();  
7.         LinkNode lq1=new LinkNode("鄭睿1");  
8.         LinkNode lq2=new LinkNode("鄭睿2");  
9.         LinkNode lq3=new LinkNode("鄭睿3");  
10.         LinkNode lq4=new LinkNode("鄭睿4");  
11.         lq.InsertLinkNode(lq1);  
12.         lq.InsertLinkNode(lq2);  
13.         lq.InsertLinkNode(lq3);  
14.         lq.InsertLinkNode(lq4);  
15.         int count=lq.getLength();  
16.         System.out.println("連結串列的長度為"+count);  
17.         for(int i=0;i<count;i++){  
18.             LinkNode ln = lq.getLinkNode(i);  
19.             System.out.println("連結串列的第"+i+"個元素的的值為"+ln.getData().toString());  
20.         }  
21.         lq.deleteLinkNode(2);  
22.         count=lq.getLength();  
23.         System.out.println("連結串列現在的長度是"+lq.getLength());  
24.         for(int i=0;i<count;i++){  
25.             LinkNode ln = lq.getLinkNode(i);  
26.             System.out.println("連結串列的第"+i+"個元素的的值為"+ln.getData().toString());  
27.         }  
28.         lq.getLinkNode(1).Update("更新後的物件鄭睿");  
29.         for(int i=0;i<count;i++){  
30.             LinkNode ln = lq.getLinkNode(i);  
31.             System.out.println("連結串列的第"+i+"個元素的的值為"+ln.getData().toString());  
32.         }  
33.         for(int i=0;i<200;i++){  
34.             LinkNode ln = new LinkNode(i);  
35.             lq.InsertLinkNode(ln);  
36.         }  
37.         System.out.println("陣列長度為"+lq.getLength());  
38.     }  
39.     /** 
40.      * 插入節點 
41.      * @param obj：插入節點的物件 
42.      */  
43.     public void InsertLinkNode(Object obj){  
44.         //當連結串列為空，新建一個節點並設定為第一個節點  
45.         if(front==null){  
46.             front=new LinkNode(obj);  
47.             last=front;  
48.         }  
49.         //當連結串列不為空，新建一個節點並插入到最後一個節點的後面  
50.         else{  
51.             LinkNode next=new LinkNode(obj);  
52.             last.next=next;  
53.             last=next;  
54.         }  
55.     }  
56.     /** 
57.      *在指定索引下插入節點 
58.      * @param index 
59.      */  
60.     public void insertIndexObj(int index,Object obj){  
61.         //判斷輸入的索引是否越界，如果越界，則丟擲異常  
62.         int total=getLength();        
63.         if(index>total||index<0)  
64.             throw new java.lang.RuntimeException("輸入的索引越界了！");  
65.         LinkNode lNode=getLinkNode(index);  
66.         LinkNode linkNode=new LinkNode(obj);  
67.         lNode.insert(linkNode);  
68.     }  
69.     /** 
70.      * 根據索引刪除連結串列 
71.      * @param index：索引 
72.      */  
73.     public void deleteLinkNode(int index){  
74.         //判斷輸入的索引是否越界，如果越界，則丟擲異常  
75.         int total=getLength();        
76.         if(index>total||index<0)  
77.             throw new java.lang.RuntimeException("輸入的索引越界了！");  
78.         if(front!=null){  
79.         LinkNode n=front;  
80.         LinkNode m=front;  
81.         int count=0;  
82.         while(n!=null){  
83.             if(count==index){  
84.                 if(n.equals(front)){  
85.                     front=front.next;  
86.                 }  
87.                 else{  
88.                     m.next=n.next;  
89.                 }  
90.             }  
91.             m=n;  
92.             n=n.next;  
93.             count++;  
94.         }  
95.         }  
96.     }  
97.     /** 
98.      * 根據索引取出節點 
99.      * @param lNode:節點 
100.      * @return：根據索引返回的節點 
101.      */  
102.     public LinkNode getLinkNode(int index){  
103.         if(front==null)  
104.         return null;  
105.         LinkNode l=front;  
106.         int count=0;  
107.         while(l!=null){  
108.             if(count==index)  
109.             return l;  
110.             count++;  
111.             l=l.next;  
112.         }  
113.         return null;  
114.     }  
115.     /** 
116.      * 得到連結串列的長度 
117.      * @return：連結串列的長度 
118.      */  
119.     public int getLength(){  
120.         if(front==null)  
121.             return 0;  
122.         LinkNode l=front;  
123.         int count=0;  
124.         while(l!=null){  
125.             count++;  
126.             l=l.next;  
127.         }  
128.         return count;  
129.     }  
130.     /** 
131.      * 修改物件節點 
132.      * @param index：物件節點索引 
133.      * @param obj：修改物件內容 
134.      */  
135. <