一塊兒學 Java（三） 集合框架、數據結構、泛型

1、Java 集合框架

集合框架是一個用來表明和操縱集合的統一架構。全部的集合框架都包含以下內容：

• 接口：是表明集合的抽象數據類型。接口容許集合獨立操縱其表明的細節。在面向對象的語言，接口一般造成一個層次。
• 實現（類）：是集合接口的具體實現。從本質上講，它們是可重複使用的數據結構。
• 算法：是實現集合接口的對象裏的方法執行的一些有用的計算，例如：搜索和排序。這些算法被稱爲多態，那是由於相同的方法能夠在類似的接口上有着不一樣的實現。

 

集合接口

序號	name	接口描述
1	Collection	Collection 是最基本的集合接口，一個 Collection 表明一組 Object，Java不提供直接繼承自Collection的類，只提供繼承於的子接口(如List和set)。
2	List	List接口是一個有序的Collection，使用此接口可以精確的控制每一個元素插入的位置，可以經過索引(元素在List中位置，相似於數組的小標)來訪問List中的元素，並且容許有相同的元素。
3	Set	Set 具備與 Collection 徹底同樣的接口，只是行爲上不一樣，Set 不保存重複的元素。
4	SortedSet	繼承於Set保存有序的集合。
5	Map	將惟一的鍵映射到值。
6	Map.Entry	描述在一個Map中的一個元素（鍵/值對）。是一個Map的內部類。
7	SortedMap	繼承於Map，使Key保持在升序排列。
8	Enumeration	這是一個傳統的接口和定義的方法，經過它能夠枚舉（一次得到一個）對象集合中的元素。這個傳統接口已被迭代器取代。

 

集合實現類（集合類）

Java提供了一套實現了Collection接口的標準集合類。其中一些是具體類，這些類能夠直接拿來使用，而另一些是抽象類，提供了接口的部分實現。

標準集合類彙總於下表：

序號	name	類描述
1	AbstractCollection	實現了大部分的集合接口。
2	AbstractList	繼承於AbstractCollection 而且實現了大部分List接口。
3	AbstractSequentialList	繼承於 AbstractList ，提供了對數據元素的鏈式訪問而不是隨機訪問。
4	LinkedList	該類實現了List接口，容許有null（空）元素。主要用於建立鏈表數據結構，該類沒有同步方法，若是多個線程同時訪問一個List，則必須本身實現訪問同步，解決方法就是在建立List時候構造一個同步的List。例如： Listlist=Collections.synchronizedList(newLinkedList(...)); LinkedList 查找效率低。
5	ArrayList	該類也是實現了List的接口，實現了可變大小的數組，隨機訪問和遍歷元素時，提供更好的性能。該類也是非同步的,在多線程的狀況下不要使用。ArrayList 增加當前長度的50%，插入刪除效率低。
6	AbstractSet	繼承於AbstractCollection 而且實現了大部分Set接口。
7	HashSet	該類實現了Set接口，不容許出現重複元素，不保證集合中元素的順序，容許包含值爲null的元素，但最多隻能一個。
8	LinkedHashSet	具備可預知迭代順序的 Set 接口的哈希表和連接列表實現。
9	TreeSet	該類實現了Set接口，能夠實現排序等功能。
10	AbstractMap	實現了大部分的Map接口。
11	HashMap	HashMap 是一個散列表，它存儲的內容是鍵值對(key-value)映射。 該類實現了Map接口，根據鍵的HashCode值存儲數據，具備很快的訪問速度，最多容許一條記錄的鍵爲null，不支持線程同步。
12	TreeMap	繼承了AbstractMap，而且使用一顆樹。
13	WeakHashMap	繼承AbstractMap類，使用弱密鑰的哈希表。
14	LinkedHashMap	繼承於HashMap，使用元素的天然順序對元素進行排序.
15	IdentityHashMap	繼承AbstractMap類，比較文檔時使用引用相等。

 

在前面的教程中已經討論經過java.util包中定義的類，以下所示：

序號	name	類描述
1	Vector	該類和ArrayList很是類似，可是該類是同步的，能夠用在多線程的狀況，該類容許設置默認的增加長度，默認擴容方式爲原來的2倍。
2	Stack	棧是Vector的一個子類，它實現了一個標準的後進先出的棧。
3	Dictionary	Dictionary 類是一個抽象類，用來存儲鍵/值對，做用和Map類類似。
4	Hashtable	Hashtable 是 Dictionary(字典) 類的子類，位於 java.util 包中。
5	Properties	Properties 繼承於 Hashtable，表示一個持久的屬性集，屬性列表中每一個鍵及其對應值都是一個字符串。
6	BitSet	一個Bitset類建立一種特殊類型的數組來保存位值。BitSet中數組大小會隨須要增長。

 

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

public class myArrayList {
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("nick");
        list.add("jenny");
        list.add("Maria");
        
        //第一種遍歷方法使用foreach遍歷List
        for (String str : list){
            System.out.println(str);
        }
        
        //第二種遍歷，把鏈表變爲數組相關的內容進行遍歷
        String[] strArray = new String[list.size()];
        list.toArray(strArray);
        for (int i=0;i<strArray.length;i++){
            System.out.println(strArray[i]);
        }
        
        //第三種遍歷 使用迭代器進行相關遍歷
        Iterator<String> ite=list.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
    }
}

myArrayList.java

package three;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class mymap {
    public static void main(String[] args){
        Map<String, String> map = new HashMap<String, String>();
        map.put("name", "nick");
        map.put("age", "18");
        map.put("single", "singleDog");
        
        //第一種：廣泛使用，二次取值
        for (String key : map.keySet()){
            System.out.println(key + " " + map.get(key));
        }
        
        //經過Map.entrySet使用iterator遍歷key和value
        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, String> entry = it.next();
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        
        //第三種：推薦，尤爲是容量大時
        for (Map.Entry<String, String> entry : map.entrySet()){
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
        
        //經過Map.values()遍歷全部的value，但不能遍歷key
        for (String v : map.values()){
            System.out.println(v);
        }
    }
}

mymap.java

 

2、Java數據結構

在Java中的數據結構主要包括如下幾種接口和類：

• 枚舉（Enumeration）
• 位集合（BitSet）
• 向量（Vector）
• 棧（Stack）
• 字典（Dictionary）
• 哈希表（Hashtable）
• 屬性（Properties）

 

枚舉（Enumeration）

Enumeration接口中定義了一些方法，經過這些方法能夠枚舉（一次得到一個）對象集合中的元素。

這種傳統接口已被迭代器取代，雖然Enumeration 還未被遺棄，但在現代代碼中已經被不多使用了。儘管如此，它仍是使用在諸如Vector和Properties這些傳統類所定義的方法中，除此以外，還用在一些API類，而且在應用程序中也普遍被使用。 下表總結了一些Enumeration聲明的方法：

序號	方法描述
1	boolean hasMoreElements( )  測試此枚舉是否包含更多的元素。
2	Object nextElement( ) 若是此枚舉對象至少還有一個可提供的元素，則返回此枚舉的下一個元素。

 

package three;

import java.util.Vector;
import java.util.Enumeration;

public class myEnumeration {
    public static void main(String[] args){
        Enumeration days;
        Vector dayNames = new Vector();
        dayNames.add("Sunday");
        dayNames.add("Monday");
        dayNames.add("Tuesday");
        dayNames.add("Wednesday");
        dayNames.add("Thursday");
        dayNames.add("Friday");
        dayNames.add("Saturday");
        days = dayNames.elements();
        while (days.hasMoreElements()){
           System.out.println(days.nextElement()); 
        }
    }
}

practice

 

位集合（BitSet）

位集合類實現了一組能夠單獨設置和清除的位或標誌。

該類在處理一組布爾值的時候很是有用，你只須要給每一個值賦值一"位"，而後對位進行適當的設置或清除，就能夠對布爾值進行操做了。

一個Bitset類建立一種特殊類型的數組來保存位值。BitSet中數組大小會隨須要增長。這和位向量（vector of bits）比較相似。

這是一個傳統的類，但它在Java 2中被徹底從新設計。

BitSet定義了兩個構造方法。

BitSet()    //第一個構造方法建立一個默認的對象
BitSet(int size)    //第二個方法容許用戶指定初始大小。全部位初始化爲0。

BitSet中實現了Cloneable接口中定義的方法以下表所列：

 

序號	方法描述
1	void and(BitSet bitSet) 對此目標位 set 和參數位 set 執行邏輯與操做。
2	void andNot(BitSet bitSet) 清除此 BitSet 中全部的位，其相應的位在指定的 BitSet 中已設置。
3	int cardinality( ) 返回此 BitSet 中設置爲 true 的位數。
4	void clear( ) 將此 BitSet 中的全部位設置爲 false。
5	void clear(int index) 將索引指定處的位設置爲 false。
6	void clear(int startIndex, int endIndex) 將指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍內的位設置爲 false。
7	Object clone( ) 複製此 BitSet，生成一個與之相等的新 BitSet。
8	boolean equals(Object bitSet) 將此對象與指定的對象進行比較。
9	void flip(int index) 將指定索引處的位設置爲其當前值的補碼。
10	void flip(int startIndex, int endIndex) 將指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍內的每一個位設置爲其當前值的補碼。
11	boolean get(int index) 返回指定索引處的位值。
12	BitSet get(int startIndex, int endIndex) 返回一個新的 BitSet，它由此 BitSet 中從 fromIndex（包括）到 toIndex（不包括）範圍內的位組成。
13	int hashCode( ) 返回此位 set 的哈希碼值。
14	boolean intersects(BitSet bitSet) 若是指定的 BitSet 中有設置爲 true 的位，而且在此 BitSet 中也將其設置爲 true，則返回 ture。
15	boolean isEmpty( ) 若是此 BitSet 中沒有包含任何設置爲 true 的位，則返回 ture。
16	int length( ) 返回此 BitSet 的"邏輯大小"：BitSet 中最高設置位的索引加 1。
17	int nextClearBit(int startIndex) 返回第一個設置爲 false 的位的索引，這發生在指定的起始索引或以後的索引上。
18	int nextSetBit(int startIndex) 返回第一個設置爲 true 的位的索引，這發生在指定的起始索引或以後的索引上。
19	void or(BitSet bitSet) 對此位 set 和位 set 參數執行邏輯或操做。
20	void set(int index) 將指定索引處的位設置爲 true。
21	void set(int index, boolean v)  將指定索引處的位設置爲指定的值。
22	void set(int startIndex, int endIndex) 將指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍內的位設置爲 true。
23	void set(int startIndex, int endIndex, boolean v) 將指定的 fromIndex（包括）到指定的 toIndex（不包括）範圍內的位設置爲指定的值。
24	int size( ) 返回此 BitSet 表示位值時實際使用空間的位數。
25	String toString( ) 返回此位 set 的字符串表示形式。
26	void xor(BitSet bitSet) 對此位 set 和位 set 參數執行邏輯異或操做。

 

package three;


import java.util.BitSet;

public class myBitset {
    public static void main(String[] args){
        BitSet bits1 = new BitSet(16);
        BitSet bits2 = new BitSet(16);
        
        // set some bits
        for(int i=0; i<16; i++) {
            if((i%2) == 0) bits1.set(i);
            if((i%5) != 0) bits2.set(i);
        }
        System.out.println("Initial pattern in bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println("\nInitial pattern in bits2: ");
        System.out.println(bits2);    // {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
        
        // AND bits
        bits2.and(bits1);
        System.out.println("\nbits2 AND bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {2, 4, 6, 8, 12, 14}
        
        // OR bits
        bits2.or(bits1);
        System.out.println("\nbits2 OR bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {0, 2, 4, 6, 8, 10, 12, 14}
        
        // XOR bits
        bits2.xor(bits1);
        System.out.println("\nbits2 XOR bits1: ");
        System.out.println(bits1);    // {0, 2, 4, 6, 8, 10, 12, 14}
        System.out.println(bits2);    // {}
    }
}

practice

 

向量（Vector）

向量（Vector）類和傳統數組很是類似，可是Vector的大小能根據須要動態的變化。

和數組同樣，Vector對象的元素也能經過索引訪問。

使用Vector類最主要的好處就是在建立對象的時候沒必要給對象指定大小，它的大小會根據須要動態的變化。

Vector類實現了一個動態數組。和ArrayList和類似，可是二者是不一樣的：

• Vector是同步訪問的。
• Vector包含了許多傳統的方法，這些方法不屬於集合框架。

Vector主要用在事先不知道數組的大小，或者只是須要一個能夠改變大小的數組的狀況。

Vector類支持4種構造方法。

Vector()    //第一種構造方法建立一個默認的向量，默認大小爲10
Vector(int size)    //第二種構造方法建立指定大小的向量
Vector(int size,int incr)    //第三種構造方法建立指定大小的向量，而且增量用incr指定. 增量表示向量每次增長的元素數目
Vector(Collection c)    //第四中構造方法建立一個包含集合c元素的向量

除了從父類繼承的方法外Vector還定義瞭如下方法：

 

序號	方法描述
1	void add(int index, Object element)   在此向量的指定位置插入指定的元素。
2	boolean add(Object o)   將指定元素添加到此向量的末尾。
3	boolean addAll(Collection c)  將指定 Collection 中的全部元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的順序添加這些元素。
4	boolean addAll(int index, Collection c)  在指定位置將指定 Collection 中的全部元素插入到此向量中。
5	void addElement(Object obj)   將指定的組件添加到此向量的末尾，將其大小增長 1。
6	int capacity()  返回此向量的當前容量。
7	void clear()  今後向量中移除全部元素。
8	Object clone()  返回向量的一個副本。
9	boolean contains(Object elem)  若是此向量包含指定的元素，則返回 true。
10	boolean containsAll(Collection c)  若是此向量包含指定 Collection 中的全部元素，則返回 true。
11	void copyInto(Object[] anArray)   將此向量的組件複製到指定的數組中。
12	Object elementAt(int index)  返回指定索引處的組件。
13	Enumeration elements()  返回此向量的組件的枚舉。
14	void ensureCapacity(int minCapacity)  增長此向量的容量（若有必要），以確保其至少可以保存最小容量參數指定的組件數。
15	boolean equals(Object o)  比較指定對象與此向量的相等性。
16	Object firstElement()  返回此向量的第一個組件（位於索引 0) 處的項）。
17	Object get(int index)  返回向量中指定位置的元素。
18	int hashCode()  返回此向量的哈希碼值。
19	int indexOf(Object elem)   返回此向量中第一次出現的指定元素的索引，若是此向量不包含該元素，則返回 -1。
20	int indexOf(Object elem, int index)   返回此向量中第一次出現的指定元素的索引，從 index 處正向搜索，若是未找到該元素，則返回 -1。
21	void insertElementAt(Object obj, int index)  將指定對象做爲此向量中的組件插入到指定的 index 處。
22	boolean isEmpty()  測試此向量是否不包含組件。
23	Object lastElement()  返回此向量的最後一個組件。
24	int lastIndexOf(Object elem)   返回此向量中最後一次出現的指定元素的索引；若是此向量不包含該元素，則返回 -1。
25	int lastIndexOf(Object elem, int index)  返回此向量中最後一次出現的指定元素的索引，從 index 處逆向搜索，若是未找到該元素，則返回 -1。
26	Object remove(int index)   移除此向量中指定位置的元素。
27	boolean remove(Object o)  移除此向量中指定元素的第一個匹配項，若是向量不包含該元素，則元素保持不變。
28	boolean removeAll(Collection c)  今後向量中移除包含在指定 Collection 中的全部元素。
29	void removeAllElements()  今後向量中移除所有組件，並將其大小設置爲零。
30	boolean removeElement(Object obj)  今後向量中移除變量的第一個（索引最小的）匹配項。
31	void removeElementAt(int index)  刪除指定索引處的組件。
32	protected void removeRange(int fromIndex, int toIndex) 今後 List 中移除其索引位於 fromIndex（包括）與 toIndex（不包括）之間的全部元素。
33	boolean retainAll(Collection c)  在此向量中僅保留包含在指定 Collection 中的元素。
34	Object set(int index, Object element)  用指定的元素替換此向量中指定位置處的元素。
35	void setElementAt(Object obj, int index)  將此向量指定 index 處的組件設置爲指定的對象。
36	void setSize(int newSize)   設置此向量的大小。
37	int size()   返回此向量中的組件數。
38	List subList(int fromIndex, int toIndex)  返回此 List 的部分視圖，元素範圍爲從 fromIndex（包括）到 toIndex（不包括）。
39	Object[] toArray()  返回一個數組，包含此向量中以恰當順序存放的全部元素。
40	Object[] toArray(Object[] a)  返回一個數組，包含此向量中以恰當順序存放的全部元素；返回數組的運行時類型爲指定數組的類型。
41	String toString()  返回此向量的字符串表示形式，其中包含每一個元素的 String 表示形式。
42	void trimToSize()    對此向量的容量進行微調，使其等於向量的當前大小。

 

package three;


import java.util.*;

public class myVector {
    public static void main(String[] args){
          Vector v = new Vector(3, 2);
          System.out.println(v.size());    // 0
          System.out.println(v.capacity());    // 3
          v.addElement(new Integer(1));
          System.out.println(v.capacity());    // 3
          v.addElement(new Integer(2));
          System.out.println(v.capacity());    // 3
          v.addElement(new Integer(3));
          System.out.println(v.capacity());    // 3
          
          v.addElement(new Integer(4));
          System.out.println(v.capacity());    // 5
          v.addElement(new Double(5.45));
          System.out.println(v.capacity());    // 5
          
          v.addElement(new Double(6.08));
          v.addElement(new Integer(7));
          System.out.println(v.capacity());    // 7
          v.addElement(new Float(9.4));
          v.addElement(new Integer(10));
          System.out.println(v.capacity());    // 9
          v.addElement(new Integer(11));
          v.addElement(new Integer(12));
          System.out.println(v.capacity());    // 11
          System.out.println((Integer)v.firstElement()); // 1
          System.out.println((Integer)v.lastElement());    // 12
          
          if(v.contains(new Integer(3)))
             System.out.println("Vector contains 3.");    //true
          
          // enumerate the elements in the vector.
          Enumeration vEnum = v.elements();
          System.out.println("\nElements in vector:");
          while(vEnum.hasMoreElements())
             System.out.print(vEnum.nextElement() + " ");
               // 1 2 3 4 5.45 6.08 7 9.4 10 11 12 
          System.out.println();
    }
}

practice

 

棧（Stack）

棧（Stack）實現了一個後進先出（LIFO）的數據結構。

你能夠把棧理解爲對象的垂直分佈的棧，當你添加一個新元素時，就將新元素放在其餘元素的頂部。

當你從棧中取元素的時候，就從棧頂取一個元素。換句話說，最後進棧的元素最早被取出。

棧是Vector的一個子類，它實現了一個標準的後進先出的棧。

堆棧只定義了默認構造函數，用來建立一個空棧。 堆棧除了包括由Vector定義的全部方法，也定義了本身的一些方法。

Stack()

除了由Vector定義的全部方法，本身也定義了一些方法：

序號	方法描述
1	boolean empty()  測試堆棧是否爲空。
2	Object peek( ) 查看堆棧頂部的對象，但不從堆棧中移除它。
3	Object pop( ) 移除堆棧頂部的對象，並做爲此函數的值返回該對象。
4	Object push(Object element) 把項壓入堆棧頂部。
5	int search(Object element) 返回對象在堆棧中的位置，以 1 爲基數。

 

package three;

import java.util.*;

public class myStack {
       static void showpush(Stack st, int a) {
          st.push(new Integer(a));
          System.out.println("push(" + a + ")");
          System.out.println("stack: " + st);
       }

       static void showpop(Stack st) {
          System.out.print("pop -> ");
          Integer a = (Integer) st.pop();
          System.out.println(a);
          System.out.println("stack: " + st);
       }
       
       public static void main(String args[]) {
          Stack st = new Stack();
          System.out.println("stack: " + st);
          showpush(st, 42);
          showpush(st, 66);
          showpush(st, 99);
          showpop(st);
          showpop(st);
          showpop(st);
          try {
               showpop(st);
             } catch (EmptyStackException e) {
               System.out.println("empty stack");
          }
       }
       /*輸出結果:
        stack: []
        push(42)
        stack: [42]
        push(66)
        stack: [42, 66]
        push(99)
        stack: [42, 66, 99]
        pop -> 99
        stack: [42, 66]
        pop -> 66
        stack: [42]
        pop -> 42
        stack: []
        pop -> empty stack
        * */
}

practice

 

字典（Dictionary）

字典（Dictionary） 類是一個抽象類，它定義了鍵映射到值的數據結構。

當你想要經過特定的鍵而不是整數索引來訪問數據的時候，這時候應該使用Dictionary。

因爲Dictionary類是抽象類，因此它只提供了鍵映射到值的數據結構，而沒有提供特定的實現。

Dictionary 類是一個抽象類，用來存儲鍵/值對，做用和Map類類似。

給出鍵和值，你就能夠將值存儲在Dictionary對象中。一旦該值被存儲，就能夠經過它的鍵來獲取它。因此和Map同樣， Dictionary 也能夠做爲一個鍵/值對列表。

Dictionary定義的抽象方法以下表所示：

序號	方法描述
1	Enumeration elements( ) 返回此 dictionary 中值的枚舉。
2	Object get(Object key) 返回此 dictionary 中該鍵所映射到的值。
3	boolean isEmpty( ) 測試此 dictionary 是否不存在從鍵到值的映射。
4	Enumeration keys( ) 返回此 dictionary 中的鍵的枚舉。
5	Object put(Object key, Object value) 將指定 key 映射到此 dictionary 中指定 value。
6	Object remove(Object key) 今後 dictionary 中移除 key （及其相應的 value）。
7	int size( ) 返回此 dictionary 中條目（不一樣鍵）的數量。

 

哈希表（Hashtable）

Hashtable類提供了一種在用戶定義鍵結構的基礎上來組織數據的手段。

例如，在地址列表的哈希表中，你能夠根據郵政編碼做爲鍵來存儲和排序數據，而不是經過人名。

哈希表鍵的具體含義徹底取決於哈希表的使用情景和它包含的數據。

Hashtable是原始的java.util的一部分， 是一個Dictionary具體的實現 。

然而，Java 2 重構的Hashtable實現了Map接口，所以，Hashtable如今集成到了集合框架中。它和HashMap類很類似，可是它支持同步。

像HashMap同樣，Hashtable在哈希表中存儲鍵/值對。當使用一個哈希表，要指定用做鍵的對象，以及要連接到該鍵的值。

而後，該鍵通過哈希處理，所獲得的散列碼被用做存儲在該表中值的索引。

Hashtable定義了四個構造方法。

Hashtable()
Hashtable(int size)    //建立指定大小的哈希表
Hashtable(int size,float fillRatio)    //建立一個指定大小的哈希表，而且經過fillRatio指定填充比例。填充比例必須介於0.0和1.0之間，它決定了哈希表在從新調整大小以前的充滿程度
Hashtable(Map m)    //建立一個以M中元素爲初始化元素的哈希表。哈希表的容量被設置爲M的兩倍。

Hashtable中除了從Map接口中定義的方法外，還定義瞭如下方法：

 

序號	方法描述
1	void clear( )  將此哈希表清空，使其不包含任何鍵。
2	Object clone( ) 建立此哈希表的淺表副本。
3	boolean contains(Object value)  測試此映射表中是否存在與指定值關聯的鍵。
4	boolean containsKey(Object key) 測試指定對象是否爲此哈希表中的鍵。
5	boolean containsValue(Object value) 若是此 Hashtable 將一個或多個鍵映射到此值，則返回 true。
6	Enumeration elements( ) 返回此哈希表中的值的枚舉。
7	Object get(Object key)  返回指定鍵所映射到的值，若是此映射不包含此鍵的映射，則返回 null. 更確切地講，若是此映射包含知足 (key.equals(k)) 的從鍵 k 到值 v 的映射，則此方法返回 v；不然，返回 null。
8	boolean isEmpty( ) 測試此哈希表是否沒有鍵映射到值。
9	Enumeration keys( )  返回此哈希表中的鍵的枚舉。
10	Object put(Object key, Object value) 將指定 key 映射到此哈希表中的指定 value。
11	void rehash( ) 增長此哈希表的容量並在內部對其進行重組，以便更有效地容納和訪問其元素。
12	Object remove(Object key) 從哈希表中移除該鍵及其相應的值。
13	int size( )  返回此哈希表中的鍵的數量。
14	String toString( ) 返回此 Hashtable 對象的字符串表示形式，其形式爲 ASCII 字符 ", " （逗號加空格）分隔開的、括在括號中的一組條目。

 

package three;


import java.util.*;

public class myHashTable {
    public static void main(String args[]) {
          // Create a hash map
          Hashtable balance = new Hashtable();
          Enumeration names;
          String str;
          double bal;

          balance.put("Zara", new Double(3434.34));
          balance.put("Mahnaz", new Double(123.22));
          balance.put("Ayan", new Double(1378.00));
          balance.put("Daisy", new Double(99.22));
          balance.put("Qadir", new Double(-19.08));

          // Show all balances in hash table.
          names = balance.keys();
          while(names.hasMoreElements()) {
             str = (String) names.nextElement();
             System.out.println(str + ": " +
             balance.get(str));
          }
          System.out.println();
          // Deposit 1,000 into Zara's account
          bal = ((Double)balance.get("Zara")).doubleValue();
          balance.put("Zara", new Double(bal+1000));
          System.out.println("Zara's new balance: " +
          balance.get("Zara"));
       }
    
    /*輸出結果
    Qadir: -19.08
    Zara: 3434.34
    Mahnaz: 123.22
    Daisy: 99.22
    Ayan: 1378.0
    
    Zara's new balance: 4434.34
     * */
}

practice

 

屬性（Properties）

Properties 繼承於 Hashtable.Properties 類表示了一個持久的屬性集.屬性列表中每一個鍵及其對應值都是一個字符串。

Properties 類被許多Java類使用。例如，在獲取環境變量時它就做爲System.getProperties()方法的返回值。

Properties 定義以下實例變量.這個變量持有一個Properties對象相關的默認屬性列表。

Properties defaults;

Properties類定義了兩個構造方法。

Properties()    //第一個構造方法沒有默認值。
Properties(Properties propDefault)    //使用propDefault 做爲默認值。
兩種狀況下，屬性列表都爲空

除了從Hashtable中所定義的方法，Properties定義瞭如下方法：

 

序號	方法描述
1	String getProperty(String key)  用指定的鍵在此屬性列表中搜索屬性。
2	String getProperty(String key, String defaultProperty) 用指定的鍵在屬性列表中搜索屬性。
3	void list(PrintStream streamOut)  將屬性列表輸出到指定的輸出流。
4	void list(PrintWriter streamOut) 將屬性列表輸出到指定的輸出流。
5	void load(InputStream streamIn) throws IOException  從輸入流中讀取屬性列表（鍵和元素對）。
6	Enumeration propertyNames( ) 按簡單的面向行的格式從輸入字符流中讀取屬性列表（鍵和元素對）。
7	Object setProperty(String key, String value)  調用 Hashtable 的方法 put。
8	void store(OutputStream streamOut, String description)  以適合使用  load(InputStream)方法加載到 Properties 表中的格式，將此 Properties 表中的屬性列表（鍵和元素對）寫入輸出流。

 

package three;


import java.util.*;

public class myProperties {
       public static void main(String args[]) {
          Properties capitals = new Properties();
          Set states;
          String str;
          
          capitals.put("Illinois", "Springfield");
          capitals.put("Missouri", "Jefferson City");
          capitals.put("Washington", "Olympia");
          capitals.put("California", "Sacramento");
          capitals.put("Indiana", "Indianapolis");

          // Show all states and capitals in hashtable.
          states = capitals.keySet(); // get set-view of keys
          Iterator itr = states.iterator();
          while(itr.hasNext()) {
             str = (String) itr.next();
             System.out.println("The capital of " +
                str + " is " + capitals.getProperty(str) + ".");
          }
          System.out.println();

          // look for state not in list -- specify default
          str = capitals.getProperty("Florida", "Not Found");
          System.out.println("The capital of Florida is "
              + str + ".");
       }
       
       /*輸出結果
        * The capital of Missouri is Jefferson City.
        The capital of Illinois is Springfield.
        The capital of Indiana is Indianapolis.
        The capital of California is Sacramento.
        The capital of Washington is Olympia.
        
        The capital of Florida is Not Found.
        * */
}

practice

 

3、泛型

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制容許程序員在編譯時檢測到非法的類型。 

泛型的本質是參數化類型，也就是說所操做的數據類型被指定爲一個參數。

泛型的好處

Java 語言中引入泛型是一個較大的功能加強。不只語言、類型系統和編譯器有了較大的變化，以支持泛型，並且類庫也進行了大翻修，因此許多重要的類，好比集合框架，都已經成爲泛型化的了。這帶來了不少好處：

類型安全。 泛型的主要目標是提升 Java 程序的類型安全。經過知道使用泛型定義的變量的類型限制，編譯器能夠在一個高得多的程度上驗證類型假設。沒有泛型，這些假設就只存在於程序員的頭腦中（或者若是幸運的話，還存在於代碼註釋中）。

Java 程序中的一種流行技術是定義這樣的集合，即它的元素或鍵是公共類型的，好比「String 列表」或者「String 到 String 的映射」。經過在變量聲明中捕獲這一附加的類型信息，泛型容許編譯器實施這些附加的類型約束。類型錯誤如今就能夠在編譯時被捕獲了，而不是在運行時看成 ClassCastException 展現出來。將類型檢查從運行時挪到編譯時有助於您更容易找到錯誤，並可提升程序的可靠性。

消除強制類型轉換。 泛型的一個附帶好處是，消除源代碼中的許多強制類型轉換。這使得代碼更加可讀，而且減小了出錯機會。

儘管減小強制類型轉換能夠下降使用泛型類的代碼的羅嗦程度，可是聲明泛型變量會帶來相應的囉嗦。

 

泛型方法

你能夠寫一個泛型方法，該方法在調用時能夠接收不一樣類型的參數。根據傳遞給泛型方法的參數類型，編譯器適當地處理每個方法調用。

下面是定義泛型方法的規則：

• 全部泛型方法聲明都有一個類型參數聲明部分（由尖括號分隔），該類型參數聲明部分在方法返回類型以前（在下面例子中的<E>）。
• 每個類型參數聲明部分包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱爲一個類型變量，是用於指定一個泛型類型名稱的標識符。
• 類型參數能被用來聲明返回值類型，而且能做爲泛型方法獲得的實際參數類型的佔位符。
• 泛型方法體的聲明和其餘方法同樣。注意類型參數只能表明引用型類型，不能是原始類型（像int,double,char的等）。

實例

下面的例子演示瞭如何使用泛型方法打印不一樣字符串的元素：

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 輸出數組元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 建立不一樣類型數組： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型數組元素爲:" );
        printArray( intArray  ); // 傳遞一個整型數組
 
        System.out.println( "\n雙精度型數組元素爲:" );
        printArray( doubleArray ); // 傳遞一個雙精度型數組
 
        System.out.println( "\n字符型數組元素爲:" );
        printArray( charArray ); // 傳遞一個字符型數組
    } 
}

/*輸出結果
整型數組元素爲:
1 2 3 4 5 

雙精度型數組元素爲:
1.1 2.2 3.3 4.4 

字符型數組元素爲:
H E L L O 
* */

View Code

 

有界的類型參數:

可能有時候，你會想限制那些被容許傳遞到一個類型參數的類型種類範圍。例如，一個操做數字的方法可能只但願接受Number或者Number子類的實例。這就是有界類型參數的目的。

要聲明一個有界的類型參數，首先列出類型參數的名稱，後跟extends關鍵字，最後緊跟它的上界。

下面的例子演示了"extends"如何使用在通常意義上的意思"extends"（類）或者"implements"（接口）。該例子中的泛型方法返回三個可比較對象的最大值。

public class MaximumTest
{
   // 比較三個值並返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假設x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 如今 z 更大           
      }
      return max; // 返回最大對象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的數爲 %d\n\n",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的數爲 %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的數爲 %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

/*輸出結果
3, 4 和 5 中最大的數爲 5

6.6, 8.8 和 7.7 中最大的數爲 8.8

pear, apple 和 orange 中最大的數爲 pear
*/

View Code

 

泛型類

泛型類的聲明和非泛型類的聲明相似，除了在類名後面添加了類型參數聲明部分。

和泛型方法同樣，泛型類的類型參數聲明部分也包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱爲一個類型變量，是用於指定一個泛型類型名稱的標識符。由於他們接受一個或多個參數，這些類被稱爲參數化的類或參數化的類型。

 以下實例演示了咱們如何定義一個泛型類:

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("嗨.."));
 
    System.out.printf("整型值爲 :%d\n\n", integerBox.get());
    System.out.printf("字符串爲 :%s\n", stringBox.get());
  }
}
/*
整型值爲 :10

字符串爲 :嗨..
*/

View Code

 

泛型類型通配符

類型通配符通常是使用?代替具體的類型參數

例如 List<?> 在邏輯上是List<String>,List<Integer> 等全部List<具體類型實參>的父類。

package three;

import java.util.ArrayList;
import java.util.List;

public class GenericTest {
     public static void main(String[] args) {
            List<String> name = new ArrayList<String>();
            List<Integer> age = new ArrayList<Integer>();
            List<Number> number = new ArrayList<Number>();
            
            name.add("nick");
            age.add(18);
            number.add(530);
     
            getData(name);
            getData(age);
            getData(number);
           
//            getUperNumber(name);    //報錯
            getUperNumber(age);
            getUperNumber(number);
       }
     
       public static void getData(List<?> data) {
          System.out.println("getData :" + data.get(0));
       }
       
       public static void getUperNumber(List<? extends Number> data) {
              System.out.println("getUperNumber :" + data.get(0));
       }
}

/*輸出結果
 * getData :nick
getData :18
getData :530
getUperNumber :18
getUperNumber :530
 * */
 

View Code