java数组和集合
一、集合的概念
集合是源于數學中的術語，集合的一些原理和算法來自于數學中的理論。在java中，集合類是用來存放對象的。對于集合的使用是通過實例化集合類得到集合對 象。而集合對象則代表以某種方式組合到一起的一組對象，對于這組對象的使用是通過引用集合對象來進行的。
通過班級的例子來給集合舉例：（示意代碼如下）
班級集合 班級A = new 班級集合（）// 班級A代表班級對象引用
// 在班級里添加學生
班級A.加入學生方法（學生對象A) ;
班級A.加入學生方法（學生對象B) ;
// 使用集合內對象
學生 學生對象1 = （學生）班級A.取得一個對象（）；
學生對象1 . 學生對象自己的方法（）；
。。。。。
。。and so on。。。
通過例子，我們看看是否有共性的部分可以提取出來呢？經分析，我們發現：
（1）、集合的操作都是相似的，向集合內添加元素（存儲），從集合中取得元素（檢索），從集合中刪除元素，修改集合的某個元素（注意，不是修改元 素本身屬性），還有其他操作（元素排序等）
（2）、集合都是用來存儲對象的（集合內存儲的每個對象我們稱為元素或者元素對象）
（3）、集合要有一定的容量，能過存放多個元素。
數組就可以實現上面的需求，但java里面還有一些重要的API來實現集合類也能實現，這時候，你就會問了，既然數組能實現容納對象的容器功能， 為什么還要設計這些集合類呢？
下面就看看集合和數組的區別：（寫一個程序例子）
import java.util.ArrayList;
public class StudentDemo {
//學生類
private String name;
private int age;
public StudentDemo(String name, int age){
this.name = name;
this.age = age;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
//先寫一個數組的例子
StudentDemo[] sArray = new StudentDemo[3];
sArray[0]=new StudentDemo("jack",20);
sArray[1]=new StudentDemo("marry",18);
sArray[2]=new StudentDemo("terry",22);
StudentDemo stu1 = sArray[0];
System.out.println("this is array="+stu1.name+"?? this age="+stu1.age);
//在寫一個集合的例子
ArrayList coll = new ArrayList();
coll.add(new StudentDemo("marryone",18));
coll.add(new StudentDemo("jackone",22));
coll.add(new StudentDemo("terryone",23));
StudentDemo stu2 = (StudentDemo)coll.get(0);
System.out.println("this is coll= "+stu2.name+"??? this is age"+stu2.age);
}
}
從例子中來比較一下數組和集合的區別:
(1).數組的長度是固定的，在定義數組的時候，就要確定數組長度大小。而集合類在定義的時候不需要確認集合所能容納對象的數量，也就是說集合的 大小是動態調整的。在實際應用中我們不能確認的需要存放元素數量的時候，采用集合是比較好的。容量可變是集合相對于數組的最大區別之一。
（2）數組既可以容納基本數據類型，也可以容納對象。而集合只能容納對象，不容納基本數據類型。另外，需要強調一點的是，無論是數組還是容器，當其容納對 象的時候，存放的都是對象的引用。而數組在容納基本數據類型的時候，持有的則是數值。
（3） 如果想在集合中容納基本數據類型，該怎么做呢？
當我們把一個對象放到集合中，該對象好像“失去”了它的型別特征，以后在使用的時候，除非使用者知道存入對象的類型，否則無法正確使用該對象。所以要像上 面的例子一樣，要進行一次強制類型的轉化
StudentDemo stu2 = (StudentDemo)coll.get(0);將其轉化為原來存儲時的對象。
二，在談談數組
在數組的處理上，除了數組本身提供的特性外，java還實現了一個工具類Arrays，提供了部分公用的static方法增強數組的處理功能。
介紹下Arrays工具類的公用方法
fill()??? -------???? 將某個數值填入到數組內
sort()? -------??? 對數組內的元素進行排序
binarySearch() ------? 在已排序的數組中查找
asList() ------?? 把數組轉換為List
等等還有一些其他的方法，這里就先介紹下sort()和binarySearch()的用法吧，一樣也是要用例子來說明的：
1，先說說sort()吧，排序需要對數組內元素進行比較，基本數據類型（比如數字、字符串）等是比較簡單的。
但是，對于對象的比較，還是需要進行一些額外的處理的。比如，對于一份學生的考試成績單來說，成績單包含的信息如學生的學號，姓名，成績等。我們 要排序的時候，就要確定要按照成績單的那個屬性進行排序的。
對于對象的比較，有兩種方法來實現。
第一種方法：欲比較的類實現Comparable接口，該類就具有了比較的能力。而實現該類接口的時候，只有一個方法compareTo() 需要實現，該方法接受另外一個對象作為比較參數，兩個對象相等時返回0，該對象小于參數對象的時候，就返回正值，大于返回負值。類實現 Comparable接口后，可以調用Arrays.sort()方法對數組內的類對象進行排序。
如：
import java.util.Arrays;
import java.util.Collections;
public class TestResult implements Comparable {
int point;
int no;
String name;
public TestResult(int point,int no,String name){
this.point = point;
this.no = no;
this.name = name;
}
public int compareTo(Object o) {
int point_cp = ((TestResult)o).point;
return (point < point_cp ? -1:(point == point_cp ? 0:1));
}
public static void main(String[] args) {
TestResult[] tra = { new TestResult(90,2,"ahang"),new??????????????????????? TestResult(80,3,"wang"),new TestResult(100,1,"zhao")};
Arrays.sort(tra);
/*使用Arrays.sort()默認的排序是升序的，那我們想要降序排列的話就使用下面的一句話就可以了*/
//Arrays.sort(tra,Collections.reverseOrder());
for(int i = 0, trsleng = tra.length; i<trsleng;i++){
System.out.println(tra[i].name + ","+tra[i].point);
}
}
}
執行結果如下：
wang,80
ahang,90
zhao,100
第二種方法：如果我們拿到一個類，但是這個類沒有實現Comparable接口，或者我們不想使用該類默認實現的Comparable接口的比較 方法，我們想采用自己的思路來排序。變通的做法就是新創建一個比較算法類，該類實現的是Comparator接口（不是Comparable接口了），實 現的時候，比較方法參數的2個對象。該比較類不是具體的比較參與對象，知識算法提供者（comparator），在需要使用排序的時候，該算法作為參數傳 遞給排序方法。（紅色字部分說的不是很簡單命了，其實我理解就是，自己寫了一個排序的方法，然后把要排序的對象做為參數傳遞進去，排序后在有該方法返回一 個排序完的結果）
例子如下：
import java.util.Arrays;
import java.util.Comparator;
/**
* 功能：由自己創建一個類并實現Comparator接口，來完成數組對對象的排序
* 作者：jackrui
* 時間：2009.3.27
*/
class ComResult implements Comparator{
public int compare(Object o1, Object o2) {
int no1 = ((TestResultComparator)o1).no;
int no2 = ((TestResultComparator)o2).no;
return (no1<no2?-1:(no1 == no2 ?0:1));
}
}
public class TestResultComparator implements Comparable{
int point;
int no;
String name;
public TestResultComparator(int point,int no,String name){
this.point = point;
this.no = no;
this.name = name;
}
public int compareTo(Object o) {
int point_cp = ((TestResultComparator)o).point;
return (point<point_cp ?-1:(point == point_cp?0:1));
}
public static void main(String[] args) {
TestResultComparator[] ra = {
new TestResultComparator(90,1,"marry"),
new TestResultComparator(100,2,"jackRui"),
new TestResultComparator(80,3,"Andy"),???????
};
//為了比較出區別，所以這里把2個實現比較的方法接口都實現了，如果用到下面這個 就可以不用實現Comparable接口
Arrays.sort(ra, new ComResult());
//下面的的注釋就是要實現Comparable接口才能實現比較
//Arrays.sort(ra);
for(int i = 0,raLength = ra.length; i < raLength;i++){
System.out.println(ra[i].name+ ","+ra[i].no);
}
}
}
2、在數組中進行查找
如何查找元素，我們在數據結構中已經學到了很多的算法，當很多算法強調的重要的一點是：數據要先排序，后查找。排序后的數組可以使用一些快速的查 詢算法，效率會更高。
Arrays.binarySearch() 就是這這種策略的一個實現，在數據結構和算法中，該方法稱為2分法。
現在改造一下上面的例子，變成如下的代碼
import java.util.Arrays;
import java.util.Comparator;
/**
* 功能：由自己創建一個類并實現Comparator接口，來完成數組對對象的排序
* 作者：jackrui
* 時間：2009.3.27
*/
class ComResult implements Comparator{
public int compare(Object o1, Object o2) {
int no1 = ((TestResultComparator)o1).no;
int no2 = ((TestResultComparator)o2).no;
return (no1<no2?-1:(no1 == no2 ?0:1));
}
}
public class TestResultComparator{
int point;
int no;
String name;
public TestResultComparator(int point,int no,String name){
this.point = point;
this.no = no;
this.name = name;
}
public static void main(String[] args) {
ComResult cm =? new ComResult();
TestResultComparator marry =
new TestResultComparator(90,3,"marry");
TestResultComparator jackRui =
new TestResultComparator(100,2,"jackRui");
TestResultComparator Andy =
new TestResultComparator(80,1,"Andy");
TestResultComparator billy =
new TestResultComparator(60,4,"billy");
TestResultComparator[] ra = {marry,jackRui,Andy};
Arrays.sort(ra,cm);
//Arrays.sort(ra);
//排序后進行查找
/*此處排序后的查找要注意的是，當使用第一種寫法的時候，即實現comparable來進行排序的時候，下面的 Arrays.binarySearch(ra, jackRui,cm)可以不用寫cm，如果要是采用第2種寫法的時候，一定要寫這個，不然的話，會報出錯的信息*/
int index1 = Arrays.binarySearch(ra, jackRui,cm);
int index2 = Arrays.binarySearch(ra, marry,cm);
int index3 = Arrays.binarySearch(ra, Andy,cm);
int index4 = Arrays.binarySearch(ra, billy,cm);
for(int i = 0,raLength = ra.length; i < raLength;i++){
System.out.println(ra[i].name+ ","+ra[i].no);
}
System.out.println();
System.out.println();
System.out.println(index1);
System.out.println(index2);
System.out.println(index3);
System.out.println(index4);
}??
}
執行結果如下：
Andy,1
jackRui,2
marry,3
1
2
0
-4
解析：輸出的結果大于等于0 表示查找到該元素，并且返回元素在數組中的索引值。
輸出的結果小于0，則表示沒有找到該元素，負值的大小表示如果該元素要插入到數組中的索引號。
需要注意的是：如果排序采用的是第2種方法，也就是單獨寫排序算法的類提供comparator，則在查找的時候，也要采用該comparator。就像 我寫的這個例子一樣。
java2 集合框架層次結構
1.1 java2集合
java2 的集合框架除了提供可變容量的“容器”特性外，還豐富了一些其他數據結構的實現，比如鏈表（linked-list），隊列（queue）
java2集合主要包含2大類：
A、 collection：collection內包含著一組單獨的元素，而根據元素存放規則又分為
（1）、List：以線性方式存儲，元素存儲有特定順序，元素可以重復。
（2）、Set：集合內元素不可以重復，Set內元素是無序的。
B、Map：一群以Key/value（鍵/值對）構成的成對對象集合，集合內的每個元素都包含2個對象--也就是成對對象。這種存儲模式類似于數據庫中 一條記錄的存儲，該記錄包含主鍵（key字段）和其他字段（組成value值），當我們想查一條記錄的時候，可以非常快速的依據主鍵數值查詢出該記錄。從 map的key值快速的查詢出value值，這是map的主要應用。key對象在map中是不可以重復的，換個角度來理解，所有的key兌現的合集就是一 個Set。
如上圖所示：
最原始的只有2中集合接口，Collection和Map 。Collection接口又有2個子接口List和Set，而在最終實現上，沒有直接基于Collection接口的實現，List、Set和Map都 有相應集合的實現類。（實際上，也是間接的實現，中間還有層抽象類）
a、List接口實現包括ArrayList和LinkedList，還有傳統的java1.1中實現的Vector，與Vector相關的還有一個 Stack。ArrayList是可變容量數組，其特性和數組很接近；LinkedList是數據結構中的鏈表，鏈表的最大特性就是對元素的刪除和添加操 作效率非常高；Vector是傳統的集合實現，已經不在推薦使用了，其實現完全可以用ArrayList和LinkedList代替。Stack是數據結 構中棧的java實現，是一種后進現出的數據結構，因為其采用的是Vector來實現，所以也不被推薦使用。
b、Set接口的實現包括HashSet和TreeSet。HashSet是數據散列，而TreeSet是一種排序的Set。
c、Map接口的實現包括HashMap、TreeMap和HashTable。HashMap是最普通的Map實現，Map內元素成散列存取。 TreeMap是排序??????????????????????? Map。HashTable是傳統的java實現，現在已經不推薦使用了，已經被HashMap代替。
d、除了集合的四種接口Collection、Map、List、Set及其相關實現類外，集合框架中還有與其（collection分支）關系密切的一 種特殊?????????????????? 接口Iterator（迭代器），而Iterator又有一個子接口實現ListIterator。Iterator對象是由Collection接口對 象產生的，而ListIterator則是由???????????????? List接口對象產生的。Collection接口對象包含Collection子接口的所有實現（List和Set接口的所有實現），也就是 說，Collection所?????????????????? 有子接口對象都可以產生Iterator對象。List接口的實現類除了可以產生?? Iterator 對象外，還可以產生ListIterator對象，那么Iterator有
什么用呢？請看下一小節。
1.2 小談一下Iterator（迭代器）
集合是存放一組元素的，元素的存入和取出必然需要集合的實現類提供方法來支持。而不同的實現類提供的方法可能不同。如果開始設計的時候我們選擇的集合是 ArrayList，后來我們發現采用LinkedList更合理。但我們要改變實現的時候，所有元素訪問的代碼（原ArrayList訪問方法）都要修 改成新的設計中的元素訪問方法（新的LinkedList訪問方法）。如果能有這樣一種思路，把“集合內元素的訪問”和“實現采用的集合”分離開。把設計 中可變因素和不可變因素分離開。這樣一種設計思想必然會降低以后程序修改和維護的代價。Iterator就是這種設計思想的體現。從集合的實現中取得 Iterator接口對象，然后通過Iterator對象遍歷集合，然后采用Iterator接口的通用方法在集合中訪問每一個元素，對于取得的元素執行 相應的動作，這種通用的對于集合遍歷的實現就是Iterator接口。
因為其通用性的原因，Iterator的功能上是比較簡單的，使用也有一些限制。比如，Iterator只能單項移動，Iterator接口提供的通用功 能如下：
（1）、從集合中獲取Iterator接口對象方法：集合對象.Iterator（），返回集合對象的Iterator接口對象。
（2）、Iterator對象.next()：從集合中取得下一個元素，返回object類型。
（3）、Iterator對象.hasnext()：檢查集合中是否還有下一個元素，返回布爾值。
（4）、Iterator對象.remove()：從集合中刪除最近獲得對象元素，返回刪除的對象。
Iterator是為遍歷而設計的，能夠從集合中取出元素和刪除元素，但是沒有添加元素的功能。集合遍歷元素的順序就是集合中元素存儲的順序。
下面就來看看Iterator一個比較普遍的使用例子：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* 功能：Iterator一個普通的小例子
* @author JackRui
* @date: 2009.03.31
*/
public class TestResultIter {
int point;
int no;
String name;
public TestResultIter(int point,int no,String name){
this.point = point;
this.no = no;
this.name = name;
}
public static void main(String[] args) {
List coll = new ArrayList();
TestResultIter jack = new TestResultIter(100,1,"jackrui");
TestResultIter mary = new TestResultIter(90,2,"mary");
TestResultIter terry = new TestResultIter(80,3,"terry");
coll.add(jack);
coll.add(mary);
coll.add(terry);
//定義一個迭代器，并指向裝載數據的集合
Iterator iter = coll.iterator();
while(iter.hasNext()){
System.out.println(((TestResultIter)iter.next()).name);
}
}
}
這里值得一說的是，集合中的元素在放入的時候會“失去”類型，所以在取出的時候，要進行強制類型轉化為當初的類型。
小記：在集合框架的體系結構中，還有一套公用工具類（Arrays和Collections）和2個比較接口（Comparable和 Comparator），我們對集合或數組的元素進行排序的時候可以使用工具類中已經提供的方法（如，Arrays.sort()），對于比較的元素，要 實現Comparable接口，或者單獨設計一個比較算法類，該類實現Comparator接口。
1.3 Collection
Collection接口是Set接口和List接口的超類，所以Collection的特性都適用于Set和List接口，而Set和List 接口在Collection的基礎上。增加了新的特性和方法。下面是Collection接口的通用方法：
Boolean add(Object) 集合中加入一個對象，成功時返回true
Boolean addAll(Collection) 集合中加入另外一個集合對象
Int size() 集合內容納元素的數量
Boolean isEmpty() 集合是否為空
Boolean contain(Object) 集合內是否有參數對象
Iterator iterator() 產生一個迭代器
Object[] toArray() 返回一個包含所有元素的對象數組
Object[] toArray(Object[]) 把所有元素放入對象數組中
Boolean remove(Object) 從集合中刪除對象
Boolean removeAll(Collection) 清空指定集合
Boolean contaunsAll(Collection) 判斷集合內是否包含子集
Boolean retainAll(Collection) 刪除子集合不包含的元素
Void clear() 清空集合
Collection中雖然提供了一些刪除的方法，如remove、removeall等，但是沒有提供get（）取出元素的方法，因 為，Collection包括了可以按照順序取的List接口外，還包含了無序的Set接口，因為無序所以無法按照順序去取元素的get（）操作。雖然沒 有實現get方法，但是對于
Collection的遍歷還是提供了通用的方法，推薦使用Iterator迭代器，而Iterator已經提供了remove和get方法。
1.3.1? List
List 是有一定順序的集合（也稱為Sequence序列），它與Set的區別是List中的元素可以重復，Set是無序的。
List對于Collection的主要增強功能有2點：
首先，因為List元素是有序性，所以每個元素都有一個Index值，與該索引值相關增加了一些方法：添加元素的時候，可以在指定集合位置添加元素。同 樣，刪除的時候也可以刪除指定位置的元素。當然，也可以按照其索引值來取出元素。
其次，可以通過List取得ListIterator來訪問List，ListIterator接口是Iterator接口的子類，其增強的地方是 Iterator只能單項遍歷，而ListIterator可以是雙向的，另外，ListIterator有增加元素的功能，而Iterator沒有此功 能。
List增加的方法：
Void (int index,Object element) 在指定索引位置添加元素
Object get(int index) 在List指定位置添加元素對象
Int indexOf(Object o) 在List中查詢元素的索引值，如果元素不存在返回-1
Int lastIndexOf(Object o) List中如果存在多個重復的元素，則indexOf返回第一個匹配元素的index，lastIndexOf（Object o）返回最后一個匹配的元素的index
ListIterator ListIterator() 返回ListIterator迭代器
Object remove(int index) 刪除集合中指定位置的元素，并把該元素返回
Object set(int index,Object element) 重新設置集合中該位置的元素
ListIterator接口除了Iterator接口已經具備的hasNext（）、next（）、remove（）方法之外，還增加了下面的 一些主要方法：
ListIterator接口方法 方法說明
Void add（int index，Object element） 在指定的索引位置添加元素
Object get(int index) 在List指定位置取得元素對象
Void add（Object o） 向集合中添加元素
Boolean hasPrevious（） 判斷集合中是否有前驅元素
Int nextIndex（） 取得集合中下一個元素的index值
Object Previous（） 取得集合中當前位置的前驅元素
Int PreviousIndex（） 取得集合中后繼元素的Index值
Void set（Object o） 更新集合當前位置元素
1.3.1.1? ArrayList
ArrayList 集合的存取方式和數組操作很類似，可以按照index順序來存取集合中的元素，但是還是建議采用更通用的迭代器來進行ArrayList的遍歷。
ArrayList與數組最大的區別就是它是可變數組，在初始化ArrayList集合的時候，可以指定一個初始化容量（Capacity 集合中可容納元素的數量），不指定的時候，系統會指定一個默認的容量值。當我們向ArrayList集合添加元素的時候，實際上是存放元素數量 （size）在不斷的增加，當容量不變，當數量增長到初始容量大小的時候，因為沒有空間導致元素添加阻塞，這時候該集合的容量會按照一定增長策略自動增 長，容量增長后，可以繼續向集合中添加元素。可變數組是ArrayList的優點，但從另外一個角度考慮，容量的增長是需要付出額外的代價的，所以在性能 上有所損失。性能問題的一種解決思路是我們可以在向集合添加大量元素之前，根據欲添加元素的數量，預先擴充容量，采用的是ensureCapacity方 法。
ArrayList是一種線性表，在內存中是連續存儲的，適合于元素的隨機存取。添加和刪除操作是需要依據添加的位置來定，如果在ArrayList最后 元素后面添加和刪除元素，在性能方面還算好，但是如果是在ArrayList中間添加和刪除元素的話，代價就會很大。因為，ArrayList需要維護整 個集合元素的順序存儲，所以需要處理欲添加和刪除元素位置之后的所有元素。
ArrayList的實現不是線程安全的。也就是說，如果有多個線程同時操作ArrayList集合對象，而且其中至少有一個線程的操作涉及到集合對象中 元素的修改（添加和刪除），則該線程內對集合對象操作的方法需要實現同步。這也是ArrayList與Vector的主要區別。在新的集合框架的實現上， 基于性能的考慮，大部分的集合設計都是線程不安全的。如果有同步需求，在用戶自己的實現中可以實現同步，實現的方法有2種：
1、在操作集合對象的方法上使用synchronized關鍵字。
2、如果方法不可修改，則可在定義集合的時候，定義同步化的集合對象（采用Collections工具類的方法），類似：
List list = Collection.synchronizedList(new ArrayList(.....));
（此處深入說明下，在采用Iterator遍歷集合的時候，如果有其他線程修改了集合（添加或刪除操作），那么Iterator的處理會中止并拋出 ConcurrentModificationException異常,這是集合處理中的Fail-safe特性）
ArrayList提供的方法中，除了Collection和List的公用方法外，又加入了一些新的方法。
ArrayList（int initialCapacity） 構造器方法增加了集合初始化的最小容量
Void ensureCapacity(int minCapacity) 預擴充ArrayList的容量
Void trimToSize() 把集合的Capacity縮小到Size的大小
下面做一個ArrayList小例子：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* @功能：ArrayList的應用小例子
* @author JackRui
* @時間：2009.03.31
*/
public class ArrayListDemo {
public static void main(String[] args) {
//利用ArrayList本身的特性
System.out.println("利用ArrayList本身的特性");
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.remove("bbb");
list.add("ddd");
for (int i=0,lsize=list.size();i<lsize;i++){
System.out.println(list.get(i));
}
//利用Iterator遍歷
System.out.println("利用Iterator遍歷");
Collection clist = new ArrayList();
clist.addAll(list);//添加元素不能采用Iterator接口
Iterator iter = clist.iterator();
while(iter.hasNext()){
String s = (String)iter.next();
if(s.equals("ddd")){
iter.remove();//可以通過Iterator接口對元素進行刪除
}else{
System.out.println(s);
}
}
//利用ListIterator遍歷???????
System.out.println("利用ListIterator遍歷");
List list2 = new ArrayList();
ListIterator lit = list2.listIterator();
if(!lit.hasNext()){
lit.add("haha");//可以通過ListIterator接口進行集合元素的添加
lit.previous();
System.out.println(lit.next());
}
}
}
運行結果如下：
利用ArrayList本身的特性
aaa
ccc
ddd
利用Iterator遍歷
aaa
ccc
利用ListIterator遍歷
haha
解析：3種方法中，第一種方法不通用，不建議使用。第2種方法最通用，但僅支持單向遍歷，而且對象的添加需要分開實現。第3種方法可以雙向遍歷， 而且可以直接使用ListIterator接口來添加對象。
問題：為什么next取得元素后，可以直接System.ou.print呢？而在String s = (String)iter.next();的時候必須進行強制類型轉化呢？
1.3.1.2? LinkedList
linkedList 是功能最強大，使用最廣泛的java集合實現類。
linkedList是數據結構中的鏈表的java實現，元素在linkedList 中的存儲是一個元素接著一個元素串聯起來，通過每個元素維護其前驅或后繼節點的連接。linkedList的線性化特征已經很弱了，因為它不需要順序存 儲，也正是這個原因，如果在需要隨機存取的場合是不太適用linkedList的，但是在添加和刪除元素的方面上，linkedList的性能還是很高 的。linkedList容納的元素的數量也是自動動態增長的。
linkedList最主要的功能方面的增強是在List的頭部或者尾部進行添加、刪除和取得元素，它直接提供了這些方法的實現。所以 linkedList可以非常方便的實現我們數據結構中常見的Stack（棧）、queue（隊列）等。
linkedList增強功能的方法如下：
Void addFirst(Object o) 在List的頭部添加對象
Void addLast(Object o) 在List尾部添加對象
Object getFirst() 從List頭部取得對象
Object getLast() 從List尾部取得對象
Object removeFirst() 從List頭部刪除對象
Object removeLast() 從List尾部刪除對象
下面寫一個linkedList的例子：
這個例子是用LinkedList設計一個測試隊列，這也可以作為我們自己的類庫來使用。（隊列的特性是（FIFO）先進現出，要注意的是，當取隊列的元 素的時候要判斷隊列是否為空，所以用到了isEmpty方法）
import java.util.LinkedList;
/**
* @功能：用LinkedList設計一個測試隊列
* @author JackRui
* @時間：2009.03.31
*
*/
public class QueueDemo {
private LinkedList list = new LinkedList();
public void put(Object o){
list.addFirst(o);
}
public Object get(){
return list.removeLast();
}
public boolean isEmpty(){
return list.isEmpty();
}
public static void main(String[] args) {
QueueDemo queue = new QueueDemo();
queue.put("one");
queue.put("two");
while(!queue.isEmpty()){
System.out.println(queue.get());
}
}
}
執行結果如下：
one
two
解析：實現了隊列的特性 先進先出，先進的順序是one two 出來也是one? two
問題：如何將隊列改成棧？如何增加判斷隊列的長度方法？該實現中是否可以采用queue繼承LinkedList來設計呢？
比較：ArrayList和LinkedList的比較：ArrayList是順序存儲，而LinkedList是鏈式存儲；ArrayList適合隨機 查找的場合，按照索引值取元素、設置元素等操作性能高，但是插入和刪除元素的性能比較差，尤其是在集合中間做插入和刪除操作，而LinkedList插入 和刪除的性能高，不適合隨機查詢。
1.3.2? Set
Set接口是collection接口的另一個子接口。它與list的區別是Set集合內存放的元素都是唯一的，不可以重復的。而且，向set里存放的元 素不是按照原來的順序存儲的。
set主要有2種集合實現，一個是HashSet，一個是TreeSet，既然都屬于Set接口，所以，這兩種集合內容納的對象也是不可以重復的。
HashSet 的特征在于其內對象的散列存取，即采用哈希技術，每個對象利用Hashcode（）方法算出一個唯一的hash值，然后在根據該hash值把各個對象盡可 能均勻分布到集合中。當讀取對象的時候，同樣先計算出對象的hash值，然后根據hash值快速到集合中相應的位置（可以理解為hash值默認的實現是與 存儲位置相關的數據）取出對象元素。自然，hashSet的優點在于快速定位元素。
HashSet內存放的對象有2個要求，除了equals方法判斷元素時候重復外，還要使用hashCode（）方法來快速定位元素，在需要的時候，這2 中方法都要覆蓋。
TreeSet雖然是存入的順序和存儲的順序是不一樣的，但是存儲是按照排序存儲的，也就是說在存儲的時候是用到了Arrays中提到的比較接口 Comparable和Comparator。
下面是一個HashSet和TreeSet的例子：
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* @功能：實現一個HashSet和TreeSet的例子
* @author JackRui
* @時間：2009.03.31
*/
public class SetDemo {
private static void printCol(Collection coll){
Iterator iter = coll.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
}
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("c");
coll.add("a");
coll.add("b");
coll.add("a");
Set set1 = new HashSet();
Set set2 = new TreeSet();
set1.addAll(coll);
set2.addAll(coll);
System.out.println("現在開始打印HashSet的內容： ");
printCol(set1);
System.out.println("現在開始打印TreeSet的內容： ");
printCol(set2);
}
}
執行結果如下：
現在開始打印HashSet的內容：
a
c
b
現在開始打印TreeSet的內容：
a
b
c
代碼解釋：從結果看到，無論是HashSet還是TreeSet，都沒有重復的值（像Set中重復存儲對象是可以執行的，但只能存儲一次罷了，這 也是Set的基本特性。）? HashSet區別的地方是對象是散列開的，具體體現在輸出上。我們輸入的順序是cab，經過HashSet存儲后輸出的順序變成acb了，而 TreeSet是有序的。
1.4? Map
Map是不同于Collection的另外一種集合接口，說到Map的適用范圍，我們先來看看一個很平常的選擇數據的例子。
我們在選擇數據的時候，我們選擇思路的依據是什么呢？比如，想從班級里選擇一個學生對象，班級中按照學生報道的先來后到順序排成學號，學號的同時代表了學 生的序號（班級里學生的索引值），學生還有姓名信息等，我們選擇的信息可能有這么幾種：
（1）、每次都取出班級最后來的學生-----棧的思路
（2）、每次都取出班級最先來的學生-----隊列的思路
（3）、按照每個學生的學號來查找學生----List的思路，如果學生的學號是連續的，則是ArrayList的思路，如果每個學生都是通過其他學生關 聯查詢出來的（比如按照座位次序），則是LinkedList思路。
（4）、如果班級里不允許重名的學生存在，這是set思路。
（5）、如果想通過學生的姓名查詢出該學生來，這就是map思路。
Map內存儲的是鍵/值對這樣以成對的對象組（可以把一組對象當成一個元素），通過“鍵”對象來查詢“值”對象，這個概念類似于數據庫中的表的查詢，表經 常會設置主鍵，主鍵對于每條記錄來說都是唯一的，所以，只要能快速的找到主鍵，就可以快速的定位到一條記錄，從而取出這條記錄，這在數據庫中使用的方法是 索引。在Map中，鍵（key）值也是唯一的，我們通過一些方法快速的找到key，而key對象和value對象是關聯在一起的，自然也就找到了 value對象，從而快速取得value值。
Map接口有2個實現，HashMap和TreeMap，HashMap中key/value對的存放和查詢是采用Hash算法，每個key對象都對應唯 一的一個hash值，根據該hash值，可以快速的定位key對象，進行快速定位到value對象。在插入元素的時候，如果key已經存在，則替換原來的 value對象。TreeMap中鍵/值對是排序（按照key排序）存儲的。
下面寫一個HashMap和TreeMap的小例子吧：
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
/**
* @功能：實現一個HashMap和TreeMap的小例子
* @author JackRui
* @時間：2009.03.31
*
*/
public class MapDemo {
int point;
int no;
String name;
public MapDemo(int point,int no,String name){
this.point = point;
this.no = no;
this.name = name;
}
private static void printCol(Collection coll){
Iterator iter = coll.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}???????
}
public static void main(String[] args) {
HashMap map1 = new HashMap();
map1.put("Zrjack", new MapDemo(100,1,"ZrJackRui"));
map1.put("mary", new MapDemo(80,2,"mary"));
map1.put("terry", new MapDemo(90,3,"terry"));
MapDemo mapdemo = (MapDemo)map1.get("Zrjack");
System.out.println("jack's result is "+mapdemo.point);
Set set1 = map1.keySet();
printCol(set1);
TreeMap map2 = new TreeMap();
map2.put("Zrjack", new MapDemo(100,1,"ZrJackRui"));
map2.put("mary", new MapDemo(80,2,"mary"));
map2.put("terry", new MapDemo(90,3,"terry"));
MapDemo mapdemo1 = (MapDemo)map1.get("Zrjack");
System.out.println("jack's result is "+mapdemo1.point);
Set set2 = map2.keySet();
printCol(set2);
}
}
執行結果：
jack's result is 100
terry
Zrjack
mary
jack's result is 100
Zrjack
mary
terry
結果分析：程序分別用了HashMap和TreeMap來存儲數據，在TreeMap的時候，進行了排序（按首字母的大小進行排序），值得注意的地方是， 排序的時候，大寫字母永遠都排在小寫字母前面，如A 要排在a的前面。
HashMap和HashTable? 的比較：HashTable是jiava傳統的實現，其工作原理和功能和HashMap和接近，但是已經不推薦使用了，HashTable是線程安全 的，HashMap不是線程安全的。從性能的角度上考慮，HashMap要比HashTable要好。
1.5 集合公用工具類&集合異常類
1.5.1 Collection 公用工具
Collection 類是類似于Arrays類的公用工具類，Arrays提供了供數組使用的公用方法，而Collection提供了一些static方法供集合類使用或操作 集合類。
Collection 中提供的方法比較多，這里說明比較常用的方法
Collection類的公用方法
Enumeration enumeration(Collection c) 返回傳統的一個遍歷接口Enumeration
Object max(Collection c) 返回集合中最大元素，需要考慮比較接口的實現
Object max(Collection c,Comparator comp) Max算法采用Comparator比較算法
Object min(Collection c) 返回集合中最小元素
Void reverse(Collection c) 把集合中的元素順序反轉
Void copy(List desc,List src) Src集合中的元素復制到desc集合
Void fill(List list, Object o) 填充list集合，填充的元素為o
Void sort(List list) 對一種list做排序
Int binarySearch(List list,Object key) 對排序后的集合list進行查詢元素操作
List synchronizedList(List list) 返回線程安全的List，同步方法還有Map，Set等的實現
在這些工具方法中，sort（）、binarySearch（）以及reverse（）在排序和查找中比較常用，再次強調的是，要使用這些方法的時候，一 是集合中的元素要實現比較接口，二是一定要先比較，再查詢。
Enumeratruon 是java1中提供的遍歷集合的接口，已經不在推薦使用了。但是在一些實現或者實際應用中，可能還會看到Enumeratruon的使用，雖然我們推薦使 用Iterator接口，但是遇到Enumeratruon接口的時候，也要能理解，Enumeratruon提供的接口方法和Iterator很相似。
1.5.2 集合處理中的常見異常
集合處理中的常用異常表如下：
ClassCastException 從集合中取得元素對象在進行類型轉換的時候類型不匹配
UnsupportedOperationException 當底層實現沒有實現上層的相關方法的時候由collection拋出異常。Collection接口（或其他集合超類）中的一些函數在java doc中是標明“可有可無（Optional）”的函數，這些函數在底層的一些具體實現中，有的實現了，有的沒有實現，當我們調用底層實現集合類的這些有 實現的方法時就會拋出該異常。
ConcurrentModificationException 當采用Iterator遍歷集合時，如果此集合中的元素被改變則Iterator遍歷拋出此異常
IndexOutOfBoundsException 集合中元素引用的索引值超出界限（<0或>size（））
NoSuchElementException LinkedList中getLast，getFirst等方法取元素的時候List為空。
以上異常都是RuntimeException的子類，在編程的時候可以不處理該異常，如果出現問題，在程序運行期間由jvm拋出。
下面寫一個關于ConcurrentModificationException異常的小例子
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
/**
* @功能：一個關于ConcurrentModificationException異常的小例子
* @author JackRui
* @時間：2009.03.31
*/
public class CollExceptionDemo {
public static void main(String[] args) {
Collection coll = new LinkedList();
Iterator iter = coll.iterator();
coll.add("a");
String s = (String)iter.next();
}
}
執行結果如下：
java.util.ConcurrentModificationException
。。。
1.5 .1 泛型
java1.5 中增加了泛型的概念，可以更方便的定義集合的數據類型和對集合中的數據進行訪問，關于泛型的概念需要單獨講解，就不在這里說了
轉載于:https://www.cnblogs.com/rafx/archive/2011/10/09/arraylist.html
總結
- 上一篇： 原来如此
- 下一篇： win7 IIS7.5 HTTP 错误