Java中有一些物件被稱為容器 (container )。容器中可以包含多個物件，每個物件稱為容器中的一個元素。容器是用物件封裝的資料結構(data structure)。

充滿夢想的容器

不同的資料結構有不同的組織元素的方式，也可以有不同的操作。根據具體實施的不同，資料結構的操作效率也各有差別。Java中的容器也是這樣。我們要選擇適當的容器，以應對變化的需求。

陣列

陣列(array)是最常見的資料結構。陣列是相同型別元素的有序集合，並有固定的大小(可容納固定數目的元素)。陣列可以根據下標(index)來隨機存取(random access)元素。在記憶體中，陣列通常是一段連續的儲存單元。

Java支援陣列這一資料結構。我們需要說明每個陣列的型別和大小。如下:

public class Test
{    public static void main(String[] args)
    {
        Human[] persons = new Human[2];              // array size 2
        persons[0] = new Human(160);
        persons[1] = new Human(170);        int[] a = {1, 2, 3, 7, 9};                   // array size 5
        System.out.println(a[2]);
        String[] names = {"Tom", "Jerry", "Luffy"};  // array size 3
        System.out.println(names[0]);
    }
}

在說明型別時，在型別說明(Human)後面增加一個 []，來說明是一個陣列。使用 new建立容器時，需要說明陣列的大小。

我們可以使用陣列名[下標] 的方式來呼叫某個元素。我們可以逐個的初始化陣列的元素，也可以在宣告的同時使用 {}初始化陣列。

對於非基本型別的陣列，比如Human[]，陣列中儲存的是物件的引用。

我們可以呼叫 System.arraycopy()方法來有效的複製陣列:

public class Test
{    public static void main(String[] args)
    {        int[] aFrom = {1, 2, 3, 7, 9}; // array size 5
        int[] aTo  = new int[3];
        System.arraycopy(aFrom, 1, aTo, 0, 3);
        System.out.println(aTo[1]);
    }
}

System.arraycopy()中， aFrom為想要複製出去的陣列， aTo為想要複製到的陣列， 1為aFrom的想要複製出去的元素起始位置， 0為aTo中想要儲存複製來元素的起始位置， 3為所要複製的元素總數。

Collection

表(List)和集合(Set)是java.util中定義的兩個介面(interface)。這兩個介面都繼承自Collection介面。透過實施介面，我們可以獲得相應的容器。

我們之前都是使用類(class)來說明引用的型別。事實上，我們也可以用介面(interface)來說明引用的型別。該型別引用所指向的物件必須實施了該介面。

我們先來使用表(List)容器。List是有序的元素集合，所以可以使用下標來說明元素的位置。集合中的元素可以相等:


import java.util.*
;
public 
class
 Test
{    
public 
static 
void
 main(String[] args)
    {
        List<String> l1 = 
new ArrayList<String>
();
        l1.add("good"
);
        l1.add("bad"
);

        l1.add("shit");

        l1.remove(0);

        System.out.println(l1.get(1));
        System.out.println(l1.size());
    }
}

當我們在定義介面和建立容器時，我們使用 <class>的方式來說明容器中所能容納元素的型別。我們將只能在容器中放入class類及其衍生類的物件。

容器的引用為List型別，但容器的實施為ArrayList類。這裡是將介面與實施分離。事實上，同一種抽象資料結構(ADT)都可以有多種實施方法(比如棧可以實施為陣列和連結串列)。這樣的分離允許我們更自由的選擇ADT的實施方式。

我們可以定義<Object>型別的容器。由於Java中的所有類都繼承自Object類，這樣的容器實際上可以放入任意型別的物件。

在上面的程式中，容器為String型別。我們用

add()方法加入新的元素
get()方法可以獲取容器中的元素，傳遞一個整數下標作為引數
remove()方法可以刪除容器中的元素，傳遞一個整數下標作為引數。(有另一個remove()，傳遞元素自身作為引數)
size()方法用來返回容器中元素的總數。

集合(set)也是元素的集合。集合中不允許有等值的元素，集合的元素沒有順序:


import java.util.*
;
public 
class
 Test
{    
public 
static 
void
 main(String[] args)
    {
        Set<Integer> s1 = 
new HashSet<Integer>
();
        s1.add(4
);
        s1.add(5
);
        s1.add(4
);

        s1.remove(5);
        System.out.println(s1);
        System.out.println(s1.size());
    }
}

重複加入的元素4只被放入容器一次。由於Set是無序的，在 remove()中，我們直接傳遞目標元素本身作為引數。

List和Set都繼承自Collection介面。Collection代表了物件的集合。上面List和Set介面中的許多方法實際上繼承自Collection，比如:

add("good") 加入元素

size() 返回元素的總數

contains("bad") 是否包含元素

remove("good") 刪除元素

Collection還有一個 iterator()的方法。該方法將Collection容器封裝成迴圈器(Iterator)。迴圈器是元素的集合，它有next()方法，用於每次返回一個元素，直到迴圈器中元素窮盡。

import java.util.*;public class Test
{    public static void main(String[] args)
    {
        List<Integer> l1 = new ArrayList<Integer>();
        l1.add(4);
        l1.add(5);
        l1.add(2);
        Iterator i = l1.iterator();        while(i.hasNext()) {
            System.out.println(i.next());
        }
    }
}

Map

Map是鍵值對的集合。Map中的每個元素是一個鍵值對，即一個鍵(key)和它對應的物件值(value)。對於Map容器，我們可以透過鍵來找到對應的物件。

雜湊表是Map常見的一種實施方式，參考紙上談兵: 雜湊表 (hash table)

我們需要宣告Map的鍵和值的型別。我們下面實施一個HashMap:

import java.util.*;public class Test
{    public static void main(String[] args)
    {
        Map<String, Integer> m1 = new HashMap<String, Integer>();
        m1.put("Vamei", 12);
        m1.put("Jerry", 5);
        m1.put("Tom", 18);
        System.out.println(m1.get("Vamei"));
    }
}

在Map中，我們使用 put()方法來新增元素，用 get()方法來獲得元素。

Map還提供了下面的方法，來返回一個Collection:

keySet() 將所有的鍵轉換為Set

values() 將所有的值轉換為List

總結

Java中，容器的介面與實施分離。這給了Java程式設計師更大的選擇自由，當然，也為程式設計增加了難度。

介面為我們提供了合法的操作。在效果層面上看，不同的實施都有相同的效果。當然，不同的情境下，實施的細節將決定執行效率。

最後，是我們提到的各個類與介面的關係:

Java進階06 容器

陣列

Collection

Map

總結

相關文章