簡單認識類集

我們學習的是面嚮物件語言，而面嚮物件語言對事物的描述是通過物件體現的，為了方便對多個物件進行操作，我們就必須把這多個物件進行儲存。而要向儲存多個物件，就不能是一個基本的變數，而應該是一個容器型別的變數，在我們目前所學過的知識裡，有哪些是容器類呢?

陣列和StringBuffer，但是呢？StringBuffer的結果是一個字串，不一定滿足我們的要求，這就是物件陣列.

而物件陣列又不能適應變化的需求，因為陣列的長度固定的，這個時候，為了適應變化的需求，Java就提供了集合類供我們使用。

陣列和集合的區別？

	長度區別	內容不同	元素的資料型別
陣列	陣列長度固定	陣列儲存的是同一種型別的元素	陣列可以儲存基本資料型別，也可以儲存引用資料型別
集合	集合長度可變	集合儲存的是不同型別的元素	集合只能儲存引用型別

在java.util包中定義了所有與類集有關的操作介面：Collection，List，Set，Map，Iteraror和Enumeration。

1.單值儲存的最大父介面:Collection[重點]

Collection介面是構造類集框架的基礎，是單值資料操作的最大父介面它宣告瞭所有類集都將擁有的核心方法。

所有類集均實現Collection。其中有幾種方法可能會引發一個UnsupportedOperationExcepation異常。這些異常將發生在修改不能被修改的類集的時候。當一個物件與另一個物件不相容，例如企圖增加一個不相容的物件到一個類集中時，將產生一個ClassCastException異常。

編號	方法名稱	描述
1	public boolean add(E e)	增加資料e到呼叫類集中。如果e被加入到類集中了，則返回true；如果此collection不允許有重複元素，並且已經包含了e，則返回false
2	public boolean addAll(Collection c)	將c中所有元素都加入到呼叫類集中，如果操作成功（元素被加入了），則返回true，否則返回false
3	public void clear()	從呼叫類集中刪除所有元素
4	public boolean contains(Object obj)	查詢資料是否存在
5	public boolean isEmpty()	判斷是否為空集合
6	public boolean remove(Object obj)	從呼叫類集中刪除obj的一個例項。如果這個元素被刪除了則返回true，否則返回false
7	public int size()	返回撥用類集中元素的個數
8	public Object[] toArray()	將集合變成物件陣列
9	public Iterator<E> iterator()	為Iterator介面例項化,迭代器

在Collection介面中一共定義了15個方法,在所有的方法中,只有兩個方法最為常用:add()和iterator().

不過開發來講,很少直接使用Collection,往往都會使用它的子介面：List（允許有重複元素，Set（不允許有重複元素）。

個人推薦:List優先考慮

2.允許重複的子介面:List

List(列表）是Collection介面之中最為常見的一個子介面。 List子介面定義：

public interface List<E> extends Collection<E>
複製程式碼

List子介面對Collection介面進行了大量的擴充。List介面擴充套件了Collection並宣告儲存一系列元素的類集的特性。

編號	方法名稱	描述
1	public void add(int index,Object obj)	將obj插入呼叫列表，插入位置的下標由index傳遞。任何已存在的，在插入點以及插入點之後的元素將後移。因此沒有元素被覆寫
2	public Object get(int index)	返回儲存在呼叫類集指定下標處物件
3	public int indexOf(Object obj)	返回撥用列表中obj第一次出現的下標。如果obj不是列表中的元素，則返回-1
4	public int lastIndexOf(Object obj)	返回撥用列表中obj最後一次出現的下標。如果obj不是列表中的元素則返回-1
5	public ListIterator listIterator()	ListIterator介面例項化
6	public Object remove(int index)	刪除呼叫列表中index位置的元素並返回刪除的元素刪除後，列表被壓縮。也就是說被刪除元素的後面的元素下標減一
7	public Object set(int index,Object obj)	用obj對呼叫列表內由index指定的位置進行賦值
8	public List subList(int start,int end)	返回一個列表，該列表包括了呼叫列表中從start到end-1的元素。返回列表中的元素也被呼叫物件引用

由於List本身還屬於介面，要想使用介面，就必須知道實現這個介面的子類，在List介面中有兩個最為常用的子類：ArrayList，Vector。

(1) 新的子類:ArrayList

ArrayList類擴充套件AbstractList並執行List介面。ArrayList支援可隨需要而增長的動態陣列。

public class ArrayList<E> 
	extends AbstractList<E> 
	implements List<E>, RandomAccess, Cloneable, Serializable
複製程式碼

在Java中，標準型別的陣列是定長的。一旦陣列被建立之後，他們不能被加長或縮短，這就意味著開發者必須事先知道陣列可以容納多少元素。一般情況下，只有在執行時才知道需要多大的陣列。為了解決這個問題，類集框架定義了ArrayList。本質上，ArrayList是物件引用的一個變長陣列。

ArrayList() 
          構造一個初始容量為 10 的空列表。 
ArrayList(Collection<? extends E> c) 
          構造一個包含指定 collection 的元素的列表，這些元素是按照該 collection 的迭代器返回它們的順序排列的。 
ArrayList(int initialCapacity) 
          構造一個具有指定初始容量的空列表 
複製程式碼

示例1:增加資料的操作

package com.shxt.demo01;

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

public class ArrayListDemo01 {

    public static void main(String[] args) {
        List<String> allList = null;                // 定義List物件
        Collection<String> allCollection = null;    // 定義Collection物件

        allList = new ArrayList<>();                // 例項化List物件,使用JDK1.7後的泛型宣告方式
        allCollection = new ArrayList<String>();    // 例項化Collection,只能是String型別

        allList.add("悟空");                         // 從Collection繼承的方法
        allList.add(0,"齊天大聖");    // List介面擴充的方法

        System.out.println(allList);                // 輸出結合的內容

        allCollection.add("豹子頭");                 // 新增資料
        allCollection.add("林沖");                   // 新增資料

        allList.addAll(allCollection);              // 從Collection繼承的方法,增加一組物件
        allList.addAll(0,allCollection);      // List擴充的方法,指定位置增加一組物件

        System.out.println(allList);                 // 輸出物件,預設情況下呼叫toString()方法

    }
}
複製程式碼

示例2:刪除元素

package com.shxt.demo01;

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

public class ArrayListDemo02 {

    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();

        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");
        allList.add("八戒");
        allList.remove(0);
        System.out.println(allList);    // 刪除指定位置的元素
        allList.remove("八戒");       // 刪除指定內容的物件
        System.out.println(allList);

    }
}
/*
執行結果:
[八戒, 唐僧, 沙僧, 八戒]
[唐僧, 沙僧, 八戒]
*/
複製程式碼

程式碼說明:

如果使用的是物件集合.例如:List<User> userList = new ArrayList<>();的形式,那麼自定義型別User需要重寫equals和hashcode方法才能完成物件的刪除

示例3:輸出List中的內容

package com.shxt.demo01;

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

public class ArrayListDemo03 {

    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();

        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");

        System.out.println("從前向後輸出:");
        for (int i = 0; i < allList.size(); i++) {
            System.out.print(allList.get(i)+"\t");
        }
        System.out.println("\n從後向前輸出:");
        for (int i = allList.size()-1; i >=0 ; i--) {
            System.out.print(allList.get(i)+"\t");
        }


    }
}
/*
從前向後輸出:
悟空	八戒	唐僧	沙僧
從後向前輸出:
沙僧	唐僧	八戒	悟空	
 */

複製程式碼

示例4:將集合變為物件陣列

package com.shxt.demo01;

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

public class ArrayListDemo04 {

    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();

        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");

        String[] array = allList.toArray(new String[]{});//指定泛型的型別
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+"\t");
        }

    }
}


複製程式碼

示例5:其他方法簡單演示

package com.shxt.demo01;

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

public class ArrayListDemo05 {

    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();

        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");
        System.out.println("判斷集合是否為空:"+allList.isEmpty());

        System.out.println("是否包含內容:"+allList.contains("八戒"));

        allList.clear();
        System.out.println("判斷集合是否為空:"+allList.isEmpty());
        
    }
}


複製程式碼

(2) 舊的子類:Vector

Vector是JDK1.0就存在的List子類,使用方式基本一致.

package com.shxt.demo02;

import java.util.List;
import java.util.Vector;

public class VectorDemo01 {
    public static void main(String[] args) {
        List<String> allList = new Vector<>();
        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");

        for (String s  : allList){
            System.out.print(s+"\t");
        }
    }
}

複製程式碼

(3) ArrayList和Vector子類的區別

編號	比較點	ArrayList	Vector
1	效能	採用非同步處理方式,效能更高	採用同步處理方式,效能較低
2	執行緒安全	屬於非執行緒安全的類	屬於執行緒安全的操作類
3	輸出方式	只能使用Iterator,Foreach輸出	可以使用Iterator,Foreach,Enumeration輸出

實際開發中使用推薦使用ArrayList

(4) LinkedList子類和Queue介面

LinkedList表示是一個連結串列的操作類,Java已經為我們提供了一個連結串列程式,我們拿來直接使用即可.

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

public interface Deque<E> extends Queue<E> {
複製程式碼

下面簡單瞭解一下介面Queue介面,Queue表示是佇列操作介面,採用FIFO(先進先出)的方式操作

Queue介面定義的方法

編號	方法名稱	型別	描述
1	public E element()	普通	找到連結串列的表頭
2	public boolean offer(E o)	普通	將指定元素增加到連結串列的結尾
3	public E peek()	普通	找到單不刪除連結串列的頭
4	public E poll()	普通	找到並刪除此連結串列的頭
5	public E remove()	普通	檢索並移除表頭

Linked子類擴充套件的方法

編號	方法名稱	型別	描述
1	public void addFirst(E o)	普通	在連結串列開頭增加元素
2	public void addLast(E o)	普通	在連結串列結尾增加元素
3	public boolean offer(E o)	普通	將指定元素增加到連結串列的結尾
4	public E removeFirst()	普通	上傳連結串列的第一個元素
5	public E removeLast()	普通	刪除連結串列的最後一個元素

示例1:連結串列新增資料

package com.shxt.demo02;

import java.util.LinkedList;

public class LinkedListDemo01 {
    public static void main(String[] args) {
        LinkedList<String> allList = new LinkedList<>();
        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");

        System.out.println("初始化資料為:"+allList);

        allList.addFirst("小白龍");
        allList.addLast("白骨精");
        System.out.println("追加資料:"+allList);
        
    }
}
複製程式碼

示例2:操作連結串列頭

package com.shxt.demo02;

import java.util.LinkedList;

public class LinkedListDemo02 {
    public static void main(String[] args) {
        LinkedList<String> allList = new LinkedList<>();
        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");

        System.out.println("1.1 element()方法找到表頭:"+allList.element());
        System.out.println("1.2 找完表頭後的連結串列內容:"+allList);

        System.out.println("2.1 peek()方法找到表頭不刪除內容:"+allList.peek());
        System.out.println("2.2 找完表頭後的連結串列內容:"+allList);

        System.out.println("3.1 poll()方法找到表頭並刪除表頭:"+allList.poll());
        System.out.println("3.2 找完表頭後的連結串列內容:"+allList);

    }
}
複製程式碼

示例3:ArrayList和LinkedList的效率比較

package com.shxt.demo02;

import java.util.ArrayList;
import java.util.LinkedList;

public class LinkedListDemo03 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        ArrayList<Integer> list01 = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list01.add(0,i);
        }
        long end = System.currentTimeMillis();
        System.out.println("ArrayList耗時為:"+(end-start)+"ms");

        start = System.currentTimeMillis();
        LinkedList<Integer> list02 = new LinkedList<>();
        for (int i = 0; i < 100000; i++) {
            list02.addFirst(i);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList耗時為:"+(end-start)+"ms");

    }
}
/*
ArrayList耗時為:1304ms
LinkedList耗時為:5ms
*/
複製程式碼

3.不允許重複的子介面:Set

Set介面也是Collection介面的子介面,但是與Collection或者List介面不同的是Set介面中不能新增重複的元素.

public interface Set<E>extends Collection<E>
複製程式碼

(1) 雜湊的存放:HashSet

HashSet是Set介面的一個子類,主要的特點是裡面不能存放重複元素,而且採用雜湊的儲存方式.所以沒有順序.

package com.shxt.demo03;

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo01 {

    public static void main(String[] args) {
        Set<String> allSet = new HashSet<String>();
        allSet.add("悟空");
        allSet.add("八戒");
        allSet.add("唐僧");
        allSet.add("唐僧");
        allSet.add("唐僧");
        allSet.add("沙僧");

        System.out.println(allSet.toString());
    }
}

複製程式碼

(2) 有序的存放:TreeSet

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
複製程式碼

package com.shxt.demo03;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo02 {

    public static void main(String[] args) {
        Set<String> allSet = new TreeSet<>();
        allSet.add("C");
        allSet.add("B");
        allSet.add("C");
        allSet.add("A");
        allSet.add("F");
        allSet.add("G");

        System.out.println(allSet.toString());
    }
}

複製程式碼

程式碼分析:

因為字串排序規則還相對簡單,如果是自定義型別,排序規則就麻煩了,需要重寫Comparable介面(可以自學)

(3) SortedSet介面

SortedSet介面繼承了Set介面,擴充套件的方式

編號	方法名稱	型別	描述
1	public Comparator<? super E> comparator()	普遍方法	返回與排序相關聯的比較器
2	public E first()	普遍方法	返回集合中的第一個元素
3	public SortedSet<E> headSet(E toElement)	普通方法	返回從開始到指定元素的集合
4	public E last()	普通方法	返回集合中的最後一個元素
5	public SortedSet<E> subSet(E fromElement,E toElement)	普通方法	返回指定物件間的元素
6	public SortedSet<E> tailSet(E fromElement)	普通方法	從指定元素的最後

package com.shxt.demo03;

import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetDemo03 {

    public static void main(String[] args) {
        SortedSet<String> allSet = new TreeSet<>();
        allSet.add("A");
        allSet.add("B");
        allSet.add("C");
        allSet.add("C");
        allSet.add("C");
        allSet.add("D");
        allSet.add("E");

        System.out.println("第一個元素:"+allSet.first());
        System.out.println("最後一個元素:"+allSet.last());
        System.out.println("headSet元素:"+allSet.headSet("C"));
        System.out.println("tailSet元素:"+allSet.tailSet("C"));
        System.out.println("subSet元素:"+allSet.subSet("B","D"));
    }
}

/*
第一個元素:A
最後一個元素:E
headSet元素:[A, B]
tailSet元素:[C, D, E]
subSet元素:[B, C]
*/
複製程式碼

4.集合的輸出

Iterator:迭代輸出,是使用最多的輸出方式
ListIterator:是Iterator的子介面,專門用於輸出List中的內容
Enumeration:是一箇舊的介面,功能與Iterator類似
foreach: JDK1.5之後提供,可以輸出陣列和集合,推薦使用

(1) 迭代輸出:Iterator

個人推薦:在使用集合輸出時必須形成一個思路,只要碰到了集合輸出的操作,就一定要使用Iterator介面,因為這是最標準的做法.Iterator是專門的迭代輸出介面,所謂的迭代輸出就是將元素一個一個判斷,判斷其是否有內容,如果有內容則把內容取出.

public interface Iterator<E>{}
複製程式碼

編號	方法名稱	型別	描述
1	public boolean hashNext()	普通方法	判斷是否有下一個元素
2	public E next()	普通方法	取出當前元素
3	public void remove()	普通方法	移除當前元素

示例1:簡單示例迭代

package com.shxt.demo03;

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

public class IteratorDemo01 {

    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();

        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");
        allList.add("八戒");

        Iterator<String> iterator = allList.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+"\t");
        }
    }
}
複製程式碼

示例2:刪除八戒的資料

package com.shxt.demo03;

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

public class IteratorDemo01 {

    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();

        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");
        allList.add("八戒");

        Iterator<String> iterator = allList.iterator();
        while (iterator.hasNext()){
           String name = iterator.next();

           if("八戒".equals(name)){
               iterator.remove();//移除
           }
        }
        System.out.println(allList);
    }
}

複製程式碼

(2) 雙向迭代輸出:ListIterator

Iterator 介面的主要功能是由前向後單向輸出,如果開發過程中不僅僅是從前往後也可能需要你重後往前輸出,那麼就需要使用Iterator 的子介面ListIterator,並且擴充套件了很多方法

編號	方法名稱	型別	描述
1	public boolean hashNext()	普通	判斷是否有下一個值
2	public E next()	普通	取出當前元素
3	public void remove()	普通	移除當前元素
4	public void add(E o)	普通	將指定元素增加集合
5	public boolean hasPrevious()	普通	判斷是否有上一個元素
6	public E previous()	普通	取出當前元素
7	public int nextIndex()	普通	返回下一個元素的索引號
8	public int previousIndex()	普通	返回上一個元素的索引號
9	public void set(E o)	普通	替換元素

package com.shxt.demo03;

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

public class ListIteratorDemo01 {
    public static void main(String[] args) {
        List<String> allList = new ArrayList<>();
        allList.add("悟空");
        allList.add("八戒");
        allList.add("唐僧");
        allList.add("沙僧");

        ListIterator<String> iterator = allList.listIterator();

        System.out.println("由前向後輸出:");
        while (iterator.hasNext()){
            String temp = iterator.next();
            System.out.print(temp+",");
        }
        System.out.println();

        System.out.println("由後向前輸出:");
        while (iterator.hasPrevious()){
            String temp = iterator.previous();
            System.out.print(temp+",");
        }

    }
}
複製程式碼

(3) Foreach

這裡就不演示了,集合支援增強for迴圈

5.Map介面

Collection/Set/List介面都屬於單值操作,即每次只能操作一個物件,而Map介面與它們不同的是每次操作的是"一對"物件,即二元偶物件,Map介面的每個每個元素都是使用"key->value"的的鍵值對形式進行儲存,Map介面定義如下:

public interface Map<K,V>
複製程式碼

編號	方法名稱	型別	描述
1	public void clear()	普通方法	清空Map集合
2	public boolean containsKey(Object key)	普通方法	判斷指定的key是否存在
3	public boolean containsValue(Object value)	普通方法	判斷指定的value是否存在
4	public Set<Map.Entry<K,V>> entrySet()	普通方法	將Map物件變為Set集合
5	public boolean equals(Object o)	普通方法	物件比較
6	public V get(Object key)	普通方法	根據key取得values
7	public int hashCode()	普通方法	返回雜湊碼
8	public boolean isEmpty()	普通方法	判斷集合是否為空
9	public Set<K> keySet()	普通方法	取得所有的key
10	public V put(K key,V value)	普通方法	想集合中加入元素
11	public void putAll(Map<? extends K,? extends V> t)	普通方法	將一個Map集合中的內容加入到另一個Map
12	public V remove(Object key)	普通方法	根據key刪除value
13	public int size()	普通方法	取出集合的長度
14	public Collection<V> values()	普通方法	取出全部的value

(1) 新的子類:HashMap

HashMap : 無序存放的,是行的操作類,key不允許重複

HashMap 本身就是Map的子類,直接使用此類為Map介面進行例項化(介面回撥)即可

HashMap類的定義如下:

public class HashMap<K,V> extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable
複製程式碼

實際開發中使用HashMap的頻率還是比較高的,我們簡單測試一下相關的示例

示例1:集合中增加和獲取內容

package com.shxt.demo04;

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

public class Demo01 {

    public static void main(String[] args) {
        Map<String,String> map  = null;
        map = new HashMap<>();
        //增加內容
        map.put("book","西遊記");
        map.put("name","吳承恩");
        map.put("type","小說");
        //獲取內容
        String value = map.get("book");
        System.out.println("獲取的內容是:"+value);

    }
}
複製程式碼

發現問題:

發現KEY的型別是Object型別,那麼意思是說不僅僅可以使用String作為KEY使用,請注意在實際開發當中大部分是使用String型別作為KEY使用,那麼我們測試一下非String的情況

package com.shxt.demo04;

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

public class Demo02 {

    public static void main(String[] args) {
        Map<Object,String> map  = null;
        map = new HashMap<>();
        //增加內容
        map.put(1,"西遊記");
        map.put(2,"吳承恩");
        map.put(3,"小說");
        //獲取內容
        String value = map.get(2);
        System.out.println("獲取的內容是:"+value);

    }
}
複製程式碼

再測試更加不合理的程式碼,純屬娛樂!

package com.shxt.demo04;

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

public class Demo03 {

    public static void main(String[] args) {
        User u1 = new User("林沖");
        User u2 = new User("劉備");


        Map<Object,String> map  = null;
        map = new HashMap<>();
        //增加內容
        map.put(u1,"西遊記");
        map.put(u2,"吳承恩");
        //獲取內容
        String value = map.get(u2);
        System.out.println("獲取的內容是:"+value);

    }
}

class User{
    private String name;

    public User(String name){
        this.name = name;
    }
}

複製程式碼

個人當然不推薦這樣的使用咯!

示例2:獲取所有的KEY和Value

package com.shxt.demo04;

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

public class Demo04 {
    public static void main(String[] args) {
        Map<String,String> map  = null;
        map = new HashMap<>();
        //增加內容
        map.put("book","西遊記");
        map.put("name","吳承恩");
        map.put("type","小說");

        Set<String> keys = map.keySet();//set集合中儲存的key
        Iterator<String> iter = keys.iterator();
        while (iter.hasNext()){
            String key = iter.next();
            String value = map.get(key);

            System.out.println("key="+key+",value="+value);
        }
    }
}
複製程式碼

(2) 舊的子類:Hashtable

Hashtable簡單瞭解一下就好,也是Map介面的一箇舊的子類

package com.shxt.demo04;

import java.util.*;

public class Demo04 {
    public static void main(String[] args) {
        Map<String,String> map  = null;
        map = new Hashtable<>();
        //增加內容
        map.put("book","西遊記");
        map.put("name","吳承恩");
        map.put("type","小說");

        Set<String> keys = map.keySet();//set集合中儲存的key
        Iterator<String> iter = keys.iterator();
        while (iter.hasNext()){
            String key = iter.next();
            String value = map.get(key);

            System.out.println("key="+key+",value="+value);
        }
    }
}
複製程式碼

HashMap 與 Hashtable 的比較

編號	比較點	HashMap	Hashtable
1	效能	採用非同步處理方式,效能高	採用同步處理方式,效能較低
2	執行緒安全	屬於非執行緒安全的操作	屬於執行緒安全的操作類
3	空鍵	允許將key設定為null	不允許key設定為null,否則會出現NullPointerException異常

(3) 排序的子類:TreeMap

package com.shxt.demo04;

import java.util.*;

public class Demo05 {
    public static void main(String[] args) {
        Map<String,String> map  = null;
        map = new TreeMap<>();
        //增加內容
        map.put("D","西遊記");
        map.put("C","吳承恩");
        map.put("Z","小說");

        Set<String> keys = map.keySet();//set集合中儲存的key
        Iterator<String> iter = keys.iterator();
        while (iter.hasNext()){
            String key = iter.next();
            String value = map.get(key);

            System.out.println("key="+key+",value="+value);
        }
    }
}
複製程式碼

JavaSE基礎:集合類