在基礎應用中，通常我們可以通過數組來保存一組具有相同屬性的對象或者基本類型的數據，但使用數組的弊端在于其大小不可更改，出于靈活性考慮，可以使用鏈表來實現動態的數組。任何事情具有兩面性，靈活性的代價就是操作上的繁瑣。在計算機世界里，處理繁瑣問題的常用方法就是將其封裝，只向外提供可調用方法的視圖。Java類集框架就是對這一方法的一種官方實現一套動態對象數組的操作類。本質上，Java類集框架就是Java對數據結構的一個大體上的封裝。
在java.util包中定義了所有與類集有關的操作接口：Collection，List，Set，Map，Iteraror，ListIterator，Enumeration。
在
在Java中，每個變量都有其所屬的數據類型，要么是基本數據類型（int，float，char等）要么是自定義的數據類型--即類。而泛型的本質就是將變量”的類型”參數化，也就是說所操作的數據類型被指定為一個參數這種參數類型可以用在類，接口和方法的創建中，分別稱為泛型類，泛型接口，泛型方法。

類集接口

在這些接口中定義了操作該類集的一些方法。支持這些方法的類集被稱為可修改的（modifiable）。不允許修改其內容的類集被稱為不可修改的（unmodifiable）。而所有內置的類集都是可修改的。如果對一個不可修改的類集使用這些方法，將引發一個UnsupportedOperationExcepation異常

單值保存的最大父接口--Collection

Collection接口是構造類集框架的基礎，是單值數據操作的最大父接口它聲明了所有類集都將擁有的核心方法。所有類集均實現Collection。其中有幾種方法可能會引發一個UnsupportedOperationExcepation異常。這些異常將發生在修改不能被修改的類集的時候。當一個對象與另一個對象不兼容，例如企圖增加一個不兼容的對象到一個類集中時，將產生一個ClassCastException異常。

在Collection接口中所提供的方法一定是日后進行程序開發中使用最多的方法，但是Collection接口很少在開發中直接使用，往往都會使用它的子接口：List（允許有重復元素，Set（不允許有重復元素）。

Collection接口的具體實現類
一些類提供了完整的可以被使用的工具。另一些類是抽象的，提供主框架工具，作為創建具體類集的起始點。沒有一個屋Collection接口是同步的，但是可以通過一些方法獲得同步版本。標準的Collection實現類如下：

除了Collection接口之外，還有幾個以前版本遺留下來的類，如Vector，Stack和Hashtable等均被重新設計成支持類集的形式。

允許重復的子接口---List
List(列表）是Collection接口之中最為常見的一個子接口。 List子接口定義：
public interface List<E> extends Collection<E>
List子接口對Collection接口進行了大量的擴充。List接口擴展了Collection并聲明存儲一系列元素的類集的特性。使用一個基于零的下標，元素可以通過他們在列表中的位置被插入和訪問。
一個列表可以包含重復的元素，即可以存在完全相同的兩個元素。除了由Collection定義的方法之外，List還定義了一些他自己的方法。注意：當類集不能被修改時，其中幾種方法將引發UnsupportedOperationException異常。當一個對象與另一個不兼容時，例如企圖將一個不兼容的對象加入一個類集中，將產生ClassCastException異常

對于由Collection定義的add()和addALL()方法，List增加了方法add(int,Object)和addALL(int,Collection)的語義也被List改變了，以便他們在列表的尾部增加元素。
為了獲得在指定位置存儲的對象，可以用對象的下標調用get()方法。為了給類集中的一個元素賦值，可以調用set()方法，指定被改變的對象的下標。調用indexOf()或lastIndexOf()可以得到一個對象的下標。通過調用subList()方法，可以獲得列表的一個指定了開始下標和結束下標的子列表。
由于List本身還屬于接口，要想使用接口，就必須知道實現這個接口的子類，在List接口中有兩個最為常用的子類：ArrayList，Vector。

ArrayList類
ArrayList類擴展AbstractList并執行List接口。ArdayList支持可隨需要而增長的動態數組。在Java中，標準類型的數組是定長的。一旦數組被創建之后，他們不能被加長或縮短，這就意味著開發者必須事先知道數組可以容納多少元素。
但是一般情況下，只有在運行時才知道需要多大的數組。為了解決這個問題，類集框架定義了ArrayList。本質上，ArrayList是對象引用的一個變長數組。也就是說，ArrayList能夠動態的增加或減小其大小。數組列表以一個原始大小被創建。當超過了它的大小時，類集自動增大，當有對象被刪除，數組就可以縮小（動態數組也被從前版本遺留下來的類Vector所支持）。

ArrayList構造方法如下：
ArrayList()
ArrayList(Collection)
ArrayList(int capacity)
第一個構造方法構造一個初始容量為10的空列表。第二個構造方法建立一個數組列表，該數組列表由類c中的元素初始化。第三個構造方法建立一個數組列表，該數組有指定的初始容量（capacity），容量用于存儲元素的基本數組的大小。當元素被追加到數組列表上時，容量會自動增加。

ArrayList類使用范例
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        //創建一個ArrayList對象
        ArrayList<String> al=new ArrayList<String>();  //尖括號<>中的String表明ArrayList的數組鏈表對象al，這個數組鏈表中的元素為String類型。尖括號<>內的數據類型是可變的，除了String類型還可以是其他類型如Integer等，這表明變量類型也是可變的---這就是Java泛型的表現
        System.out.println("a1中元素的個數"+al.size());
        //向ArrayList對象中添加新內容
        al.add("C");   //在數組列表0位置添加元素C
        al.add("A");   //在數組列表1位置添加元素A
        al.add("E");   //在數組列表2位置添加元素E
        al.add("B");   //在數組列表3位置添加元素B
        al.add("D");   //在數組列表4位置添加元素D
        al.add("F");   //在數組列表5位置添加元素F
        al.add(1,"A2");  //把A2加在ArrayList對象的第二個位置
        System.out.println("a1加入元素之后的元素個數:"+al.size());
        System.out.println("a1的內容:"+al);   //顯示ArrayList數據
        al.remove("F");  //刪除元素F
        al.remove(2);  //刪除下標為2的元素
        System.out.println("a1刪除元素之后的元素個數:"+al.size());
        System.out.println("a1的內容:"+al);
        
    }
}

當對象被存儲在ArrayList對象中時，其容量會自動增加。然而也可以調用ensureCapacity()方法來人工增加ArrayList的容量。如果事先知道將在當前的類集中存儲大量數據時，可以這么做。在開始通過一次性人工增加它的容量，就能避免后面的再分配。因為在分配很花時間，避免不必要的處理可以提高性能。

ArrayList類使用范例
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        //創建一個ArrayList對象al
        ArrayList<Integer> al=new ArrayList<Integer>();
        //向ArrayList中加入對象
        al.add(new Integer(1));
        al.add(new Integer(2));
        al.add(new Integer(3));
        al.add(new Integer(4));
        System.out.println("ArrayList中的內容:"+al);
        //得到對象數組
        Object ia[]=al.toArray();
        int sum=0;
        //計算數組內容
        for(int i=0;i<ia.length;i++)
        {
            sum+=((Integer)ia[i].intValue();   //將元素轉換成Integer類型并取值
        }
        System.out.println("數組累加結果是:"+sum);
    }
}

LinkedList類
LinkedList類擴展了AbstractSequentialList類并實現List接口它提供了一個鏈接列表的數據結構。構造方法如下：
LinkedList()
LinkedList(Collection c)
第一個構造方法建立一個空的鏈接列表。第二個構造方法建立一個鏈接列表。該鏈接列表由類c中的元素初始化。
除了它繼承的方法之外，LikedList類本身還定義了一些有用的方法，這些方法主要用于操作和訪問列表。使用addFirst()方法可以在列表頭增加元素，使用addLast()方法可以在列表的尾部增加元素。形式如下：
void addFirst(Object obj)
void addLast(Object obj)
在這里obj是被增加的對象。
調用getFirst()方法可以獲得第一個元素，調用getLast()方法可以得到最后一個元素。形式如下：
Object getFirst();
Object getLast();
為了刪除第一個元素，可以使用removeFirst()方法。刪除最后一個元素，可以調用removeLast()方法。形式如下：
Object removeFirst();
Object removeLast();

LinkedList類的使用**
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        LinkedList<String> LL=new LinkedList<String>();
        //加入元素到LinkedList對象
        LL.add("F");
        LL.add("F");
        LL.add("D");
        LL.add("E");
        LL.add("C");
        //在鏈表的最后一個位置加上數據
        LL.addLast("Z");
        //在鏈表的第一個位置加上數據
        LL.addFirst("A");
        //在鏈表第二個元素的位置加上數據
        LL.add(1,"A2");
        System.out.println("LL最初的內容:"+LL);
        //從LinkedList中移除元素
        LL.remove("F");
        System.out.println("刪除元素Fh后LL的內容:+"+LL);
        LL.remove(2);
        System.out.println("從LL中移除第二個元素后的內容:"+LL);
        //移除第一個和最后一個元素
        LL.removeFirst();
        LL.removeLast();
        System.out.println("LL移除第一個和最后一個元素之后的內容:"+LL);
        //取得并設值
        Object val=LL.get(2);
        LL.set(2,(String)val+"Changed");
        System.out.println("LL被改變之后:"+LL);
    }
}

舊的子類---Vector
Vector實現動態數組，與ArrayList相似，但兩者不同的是：Vector是同步的，并且它包含了許多不屬于類集框架的從以前版本遺留下來的方法。隨著Java2的公布，Vector被重新設計來擴展AbstractList和實現List接口，因此他是與類集完全兼容的。下面構造方法：
Vector()
Vector(int size)
Vector(int size,int incr)
Vector(Collection c)
第一種形式創建一個原始大小為10的默認矢量。第二種形式創建一個其原始容量由size指定的矢量。第三種形式創建一個其原始容量由size指定，并且它的增量由incr指定的矢量，增量指定了矢量每次允許向上改變大小的元素個數。第四種形式創建一個包含類集c中元素的矢量。
所有矢量開始都有一個原始的容量。在這個原始容量達到以后，下次在試圖向矢量中存儲對象時，矢量會自動為那個對象分配空間，同時分別為對象增加額外的空間。通過分配超過需要的內存，減小了矢量可能產生的分配次數。這種次數的減少是很重要的，因為分配內存很花時間，在每一次再分配中，分配的額外空間的總數由在創建矢量時指定的增量來確定。如果沒有指定增量，在分配周期，矢量的大小增加一倍。
Vector定義了下面的保護數據成員：
int capacityIncrement;
int elementCount;
Object elementData[ ];
增量值被存儲在capacityIncrement中，矢量中的當前元素的個數被存儲在elementCount中，保存矢量的數組被存儲在elementData中。
除了由List定義類集方法之外，Vector還定義了幾個以前版本遺留下來的方法：

因為Vector實現List，所以可以像使用ArrayList的一個實例那樣使用矢量。也可以使用從它的以前版本遺留下來的方法來操作她。例如，在后面實例化Vector，可以通過調用addElement()方法而為其增加一個元素。調用element()可以獲得指定位置處的元素。
調用firstElement()方法可以得到矢量的第一個元素，調用lastElement()可以檢索到矢量的最后一個元素，使用indexOf()和lastIndexOf()方法可以獲得元素的下標，調用removeElement()或removeElementAt()方法可以刪除元素。

使用矢量存儲不同類型的數值對象
import java.util.*;
class jdjdkdxk
{
    public static void main(String args[])
    {
        Vector<String> v=new Vector<String>();
        v.add("A");
        v.add("B");
        v.add("C");
        v.add("D");
        v.add("E");
        v.add("F");
        Enumeration<String> e=v.elements();
        while(e.hasMoreElements())
        {
            System.out.println(e.nextElement()+"   ");
        }
    }
}
枚舉方法nextElement()用于獲得枚舉中的下一個元素

Java2以后，Vector增加了對迭代（Iterator)方法的支持。可以使用迭代方法來代替枚舉去遍歷對象。下例基于迭代方法的程序代碼可以被替換到上面的程序中

import java.util.*;
class jdjdkdxk
{
    public static void main(String args[])
    {
        Vector v=new Vector();
        v.add("A");
        v.add("B");
        v.add("C");
        Iterator i=v.iterator();
        while(i.hasNext())
        {
            System.out.println(i.next()+"\t");
        }
    }
}

數組操作類------Arrays
本質上，類集本身是一個對象數組。java.util.Arrays類是可以操作數組的。Arrays類數組操作類，可用來操作數組（如數組元素排序，搜索和填充等）的各種方法。Arrays類常用如下方法表示：

使用數組操作類Arrays的使用（ArrayDemo.java)

import java.util.List;
public class ArrayDemo
{
public static void main(String args[])
{
List<String> all=Arrays.asList("Hello","World","你好","世界"）；
System.out.println(all);
}
}

數組操作類Arrays排序及二分查找方法的使用

import java.util.Arrays;
import java.util.Scanner;
class ArraysDemo
{
    public static void main(String args[])
    {
        int arrInt[]={17,40,12,6,15,16,8,10,18,50};
        //升序排序數組
        Arrays.sort(arrInt);
        Scanner scan =new Scanner(System.in);
        System.out.println("請輸入需要查找的整數:");
        //獲取輸入整數
        int search=scan.nextInt();
        //輸出排序后的數組
        for(int i=0;i<arrInt.length;i++)
        {
            //System.out.println(arrInt(i)+ " ");
        }
        //利用二分法查找指定整數
        int seaInt=Arrays.binarySearch(arrInt,search);
        if(seaInt>=0)
        {
            System.out.println(search+" 是數組得第 "+(seaInt+1)+" 位元素");
        }
        else
        {
            System.out.println(search +"不是數組得元素");
        }
        scan.close();   //關閉輸入流
    }
}

比較器

需要為多個對象排序時必須設置排序規則，而排序規則就可以通過比較器進行設置，Java中比較器提供了兩種：Comparable和Comparator

Comparable接口
Comparable是一個要進行多個對象比較的類需要默認實現的一個接口，這個接口定義如下：
public interface Comparable<T>
{public int comparableTo(T o)};//T是對象類型，o是對象類型所定義得對象
從接口定義的格式來看，可以發現要想實現對象得排序功能，要實現Comparable接口，并覆寫comparable(T o)方法。此方法返回得是一個int類型數據，該返回值只能有以下三種情況之一
1，相等：0；
2，大于：1；
3，小于：-1；