❶ java中Vector和ArrayList的區別
是的, 這是一個太多太多人遇到過, 討論過, 解釋過的問題.
為了加深自己的記憶, 還是決定寫一篇來記錄下他.
首先想說的是:
Vector是在Collections API之前就已經產生了的, 而ArrayList是在JDK1.2的時候才作為Collection framework的一部分引入的. 它們都是在內部用一個Obejct[]來存儲元素的.
ok, 現在來說他們的差別:
1. 線程安全
Vector是同步的, 而ArrayList不是.
因為Vector是同步的, 所以它是線程安全的.
同樣, 因為Vecotr是同步的, 所以他需要額外的開銷來維持同步鎖, 所以它要比ArrayList要慢.(理論上來說)
當然, 如果你對ArrayList有偏好, 你也可以用Collection.synchronizedList(List)來得到一個線程安全的List.
2. 容量增長
Vector允許用戶設置capacityIncrement這樣在每次需要擴充數組的size的時候, Vector會嘗試按照預先設置的capacityIncrement作為增量來設置, 而ArrayList則會把數組的大小擴大一倍.
比如現在同樣一個長度為10的Vector和ArrayList, 我們把Vector的capacityIncrement設為1
那麼我們在插入第11個對象的時候, Vector會將長度變成11, 然後分配空間, 然後將對象添加進去, 而ArrayList則會分配20個對象的空間, 然後將對象添加進去.
如果capacityIncrement設為0或者負值, Vector就會做和ArrayList一樣, 每次都將數組大小擴大一倍.
3. 性能比較
剛剛在上面已經說過了, 由於Vector是同步的, 而ArrayList不是, 所以Vector的性能要比ArrayList要稍第一點, 用性能換安全嘛.
不過, 據Jack Shirazi在OnJava上的一篇文章來看, 似乎這並不是什麼問題, 他認為對於現在的JVM來說, 這兩個類在同步這個問題上的性能差異, 甚至還不如每次跑測試的時候環境變化引起的差異大.
Consequently Vector is thread-safe, and ArrayList isn't. This makes ArrayList faster than Vector. For some of the latest JVMs the difference in speed between the two classes is negligible: strictly speaking, for these JVMs the difference in speed between the two classes is less than the variation in times obtained from tests comparing the performance of these classes. ---- The Performance of Java's Lists
這樣看來, 性能上的差別應該不大.
So, as a conclusion.
結論和網上大多數人得到的結論一樣:
在一般情況下, 還是鼓勵用ArrayList的, 如果你有同步控制的需要, 那就用Vector吧, 也懶得用Collection.synchronizedList(List)再去轉一次了, 除非非這樣不可.. 不然還是順應潮流, 畢竟, 代碼是寫給人看的. 在無傷大雅的情況下, 按照common的法則來寫, 無疑會讓看代碼的人更快理解. :)
❷ JAVA中的List、Vector、ArrayList的差異
Java 中Vector、ArrayList和LinkedList 的區別Java 中Vector、ArrayList和LinkedList 的區別SDK提供了有序集合介面java.util.List的幾種實現，其中三種最為人們熟知的是Vector、ArrayList和LinkedList。有關這些List類的性能差別是一個經常被問及的問題。在這篇文章中，我要探討的就是LinkedList和Vector/ArrayList之間的性能差異。為全面分析這些類之間的性能差異，我們必須知道它們的實現方法。因此，接下來我首先從性能的角度出發，簡要介紹這些類的實現特點。一、Vector和ArrayList的實現
Vector和ArrayList都帶有一個底層的Object[]數組，這個Object[]數組用來保存元素。通過索引訪問元素時，只需簡單地通過索引訪問內部數組的元素：
public Object get(int index)
{ //首先檢查index是否合法...此處不顯示這部分代碼 return
elementData[index]; } 內部數組可以大於Vector/ArrayList對象擁有元素的數量，兩者的差值作為剩餘空間，以便實現快速添加新元素。有了剩餘空間，添加元素變得非常簡單，只需把新的元素保存到內部數組中的一個空餘的位置，然後為新的空餘位置增加索引值：
public boolean add(Object o)
{ ensureCapacity(size + 1); //稍後介紹 elementData[size++] = o; return true;
//List.add(Object) 的返回值 }
把元素插入集合中任意指定的位置（而不是集合的末尾）略微復雜一點：插入點之上的所有數組元素都必須向前移動一個位置，然後才能進行賦值：
public void add(int index, Object element) {
//首先檢查index是否合法...此處不顯示這部分代碼
ensureCapacity(size+1);
System.array(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
剩餘空間被用光時，如果需要加入更多的元素，Vector/ArrayList對象必須用一個更大的新數組替換其內部Object[]數組，把所有的數組元素復制到新的數組。根據SDK版本的不同，新的數組要比原來的大50%或者100%（下面顯示的代碼把數組擴大100%）：
public void ensureCapacity(int minCapacity) {
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = Math.max(oldCapacity * 2, minCapacity);
elementData = new Object[newCapacity];
System.array(oldData, 0, elementData, 0, size);
}
}
Vector類和ArrayList類的主要不同之處在於同步。除了兩個只用於串列化的方法，沒有一個ArrayList的方法具有同步執行的能力；相反，Vector的大多數方法具有同步能力，或直接或間接。因此，Vector是線程安全的，但ArrayList不是。這使得ArrayList要比Vector快速。對於一些最新的JVM，兩個類在速度上的差異可以忽略不計：嚴格地說，對於這些JVM，這兩個類在速度上的差異小於比較這些類性能的測試所顯示的時間差異。通過索引訪問和更新元素時，Vector和ArrayList的實現有著卓越的性能，因為不存在除范圍檢查之外的其他開銷。除非內部數組空間耗盡必須進行擴展，否則，向列表的末尾添加元素或者從列表的末尾刪除元素時，都同樣有著優秀的性能。插入元素和刪除元素總是要進行數組復制（當數組先必須進行擴展時，需要兩次復制）。被復制元素的數量和[size-index]成比例，即和插入/刪除點到集合中最後索引位置之間的距離成比例。對於插入操作，把元素插入到集合最前面（索引0）時性能最差，插入到集合最後面時（最後一個現有元素之後）時性能最好。隨著集合規模的增大，數組復制的開銷也迅速增加，因為每次插入操作必須復制的元素數量增加了。二、LinkedList的實現
LinkedList通過一個雙向鏈接的節點列表實現。要通過索引訪問元素，你必須查找所有節點，直至找到目標節點：
public Object get(intindex) {
//首先檢查index是否合法...此處不顯示這部分代碼
Entry e = header; //開始節點
//向前或者向後查找，具體由哪一個方向距離較
//近決定
if (index < size/2) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
把元素插入列表很簡單：找到指定索引的節點，然後緊靠該節點之前插入一個新節點：
public void add(int index, Object element) {
//首先檢查index是否合法...此處不顯示這部分代碼
Entry e = header; //starting node
//向前或者向後查找，具體由哪一個方向距離較
//近決定
if (index < size/2) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
Entry newEntry = new Entry(element, e, e.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
}
線程安全的LinkedList和其他集合
如果要從Java SDK得到一個線程安全的LinkedList，你可以利用一個同步封裝器從Collections.synchronizedList(List)得到一個。然而，使用同步封裝器相當於加入了一個間接層，它會帶來昂貴的性能代價。當封裝器把調用傳遞給被封裝的方法時，每一個方法都需要增加一次額外的方法調用，經過同步封裝器封裝的方法會比未經封裝的方法慢二到三倍。對於象搜索之類的復雜操作，這種間接調用所帶來的開銷不是很突出；但對於比較簡單的方法，比如訪問功能或者更新功能，這種開銷可能對性能造成嚴重的影響。這意味著，和Vector相比，經過同步封裝的LinkedList在性能上處於顯著的劣勢，因為Vector不需要為了線程安全而進行任何額外的間接調用。如果你想要有一個線程安全的LinkedList，你可以復制LinkedList類並讓幾個必要的方法同步，這樣你可以得到一個速度更快的實現。對於所有其它集合類，這一點都同樣有效：只有List和Map具有高效的線程安全實現（分別是Vector和Hashtable類）。有趣的是，這兩個高效的線程安全類的存在只是為了向後兼容，而不是出於性能上的考慮。對於通過索引訪問和更新元素，LinkedList實現的性能開銷略大一點，因為訪問任意一個索引都要求跨越多個節點。插入元素時除了有跨越多個節點的性能開銷之外，還要有另外一個開銷，即創建節點對象的開銷。在優勢方面，LinkedList實現的插入和刪除操作沒有其他開銷，因此，插入-刪除開銷幾乎完全依賴於插入-刪除點離集合末尾的遠近。
ArrayList和Vector通常比LinkedList和同步封裝之後的LinkedList有著更好的性能。即使在你認為LinkedList可能提供更高性能的情況下，你也可以通過修改元素加入的方式從ArrayList爭取更好的性能，例如翻轉集合元素的次序。有些情況下LinkedList會有更好的性能，例如，當大量元素需要同時加入到大型集合的開頭和末尾時。但一般而言，我建議你優先使用ArrayList/Vector類，只有當它們存在明顯的性能問題而LinkedList能夠改進性能時，才使用LinkedList。
❸ Java中Vector和ArrayList的區別
首先看這兩類都實現List介面，而List介面一共有三個實現類，分別是ArrayList、Vector和LinkedList。List用於存放多個元素，能夠維護元素的次序，並且允許元素的重復。3個具體實現類的相關區別如下：1.ArrayList是最常用的List實現類，內部是通過.
❹ Java中Vector和ArrayList的區別
首先看這兩類都實現List介面，而List介面一共有三個實現類，分別是ArrayList、Vector和LinkedList。List用於存放多個元素，能夠維護元素的次序，並且允許元素的重復。3個具體實現類的相關區別如下：
ArrayList是最常用的List實現類，內部是通過數組實現的，它允許對元素進行快速隨機訪問。數組的缺點是每個元素之間不能有間隔，當數組大小不滿足時需要增加存儲能力，就要講已經有數組的數據復制到新的存儲空間中。當從ArrayList的中間位置插入或者刪除元素時，需要對數組進行復制、移動、代價比較高。因此，它適合隨機查找和遍歷，不適合插入和刪除。
Vector與ArrayList一樣，也是通過數組實現的，不同的是它支持線程的同步，即某一時刻只有一個線程能夠寫Vector，避免多線程同時寫而引起的不一致性，但實現同步需要很高的花費，因此，訪問它比訪問ArrayList慢。
LinkedList是用鏈表結構存儲數據的，很適合數據的動態插入和刪除，隨機訪問和遍歷速度比較慢。另外，他還提供了List介面中沒有定義的方法，專門用於操作表頭和表尾元素，可以當作堆棧、隊列和雙向隊列使用。
查看Java源代碼，發現當數組的大小不夠的時候，需要重新建立數組，然後將元素拷貝到新的數組內，ArrayList和Vector的擴展數組的大小不同。
ArrayList中：
1publicbooleanadd(Ee){
2
3ensureCapacity(size+1);//增加元素，判斷是否能夠容納。不能的話就要新建數組
4
5elementData[size++]=e;
6
7returntrue;
8
9}
10
11publicvoidensureCapacity(intminCapacity){
12
13modCount++;
14
15intoldCapacity=elementData.length;
16
17if(minCapacity>oldCapacity){
18
19ObjectoldData[]=elementData;//此行沒看出來用處，不知道開發者出於什麼考慮
20
21intnewCapacity=(oldCapacity*3)/2+1;//增加新的數組的大小
22
23if(newCapacity<minCapacity)
24
25newCapacity=minCapacity;
26
27//,sothisisawin:
28
29elementData=Arrays.Of(elementData,newCapacity);
30
31}
32
33}
34
35
Vector中：
(intminCapacity){
2
3intoldCapacity=elementData.length;
4
5if(minCapacity>oldCapacity){
6
7Object[]oldData=elementData;
8
9intnewCapacity=(capacityIncrement>0)?
10
11(oldCapacity+capacityIncrement):(oldCapacity*2);
12
13if(newCapacity<minCapacity){
14
15newCapacity=minCapacity;
16
17}
18
19elementData=Arrays.Of(elementData,newCapacity);
20
21}
22
23}
24
25
關於ArrayList和Vector區別如下：
ArrayList在內存不夠時默認是擴展50%+1個，Vector是默認擴展1倍。
Vector提供indexOf(obj,start)介面，ArrayList沒有。
Vector屬於線程安全級別的，但是大多數情況下不使用Vector，因為線程安全需要更大的系統開銷。
❺ Java中Vector和ArrayList的區別
首先看這兩類都實現List介面，而List介面一共有三個實現類，分別是ArrayList、Vector和LinkedList。List用於存放多個元素，能夠維護元素的次序，並且允許元素的重復。3個具體實現類的相關區別如下：1.ArrayList是最常用的List實現類，內部是通過數組實現的，它允許對元素進行快速隨機訪問。數組的缺點是每個元素之間不能有間隔，當數組大小不滿足時需要增加存儲能力，就要講已經有數組的數據復制到新的存儲空間中。當從ArrayList的中間位置插入或者刪除元素時，需要對數組進行復制、移動、代價比較高。因此，它適合隨機查找和遍歷，不適合插入和刪除。2.Vector與ArrayList一樣，也是通過數組實現的，不同的是它支持線程的同步，即某一時刻只有一個線程能夠寫Vector，避免多線程同時寫而引起的不一致性，但實現同步需要很高的花費，因此，訪問它比訪問ArrayList慢。3.LinkedList是用鏈表結構存儲數據的，很適合數據的動態插入和刪除，隨機訪問和遍歷速度比較慢。另外，他還提供了List介面中沒有定義的方法，專門用於操作表頭和表尾元素，可以當作堆棧、隊列和雙向隊列使用。查看Java源代碼，發現當數組的大小不夠的時候，需要重新建立數組，然後將元素拷貝到新的數組內，ArrayList和Vector的擴展數組的大小不同。ArrayList中：
代碼如下:
public boolean add(E e) {
ensureCapacity(size + 1); // 增加元素，判斷是否能夠容納。不能的話就要新建數組
elementData[size++] = e;
return true;
}
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData; // 此行沒看出來用處，不知道開發者出於什麼考慮
int newCapacity = (oldCapacity * 3)/2 + 1; // 增加新的數組的大小
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.Of(elementData, newCapacity);
}
}
Vector中：
代碼如下:
private void ensureCapacityHelper(int minCapacity) {
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object[] oldData = elementData;
int newCapacity = (capacityIncrement > 0) ?
(oldCapacity + capacityIncrement) : (oldCapacity * 2);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
elementData = Arrays.Of(elementData, newCapacity);
}
}
關於ArrayList和Vector區別如下：1.ArrayList在內存不夠時默認是擴展50% + 1個，Vector是默認擴展1倍。2.Vector提供indexOf(obj, start)介面，ArrayList沒有。3.Vector屬於線程安全級別的，但是大多數情況下不使用Vector，因為線程安全需要更大的系統開銷。
❻ Java中Vector和ArrayList的區別
List是介面 ,定義了一些方法 但是方法沒有被實現 ,ArrayList是一個類 ,實現了List這個介面. List里邊定義的方法 ,在ArrayList里邊都實現了, 同時List也可以被別的類所實現, 例如Vector， Vector和ArrayList對List定義的方法的實現就有所區別。
1.List是介面，List特性就是有序,會確保以一定的順序保存元素.
ArrayList是它的實現類,是一個用數組實現的List.
Map是介面,Map特性就是根據一個對象查找對象.
HashMap是它的實現類,HashMap用hash表實現的Map,就是利用對象的hashcode(hashcode()是Object的方法)進行快速散列查找.(關於散列查找,可以參看<<數據結構>>)
2.一般情況下,如果沒有必要,推薦代碼只同List,Map介面打交道.
比如:List list = new ArrayList();
這樣做的原因是list就相當於是一個泛型的實現,如果想改變list的類型,只需要:
List list = new LinkedList();//LinkedList也是List的實現類,也是ArrayList的兄弟類
這樣,就不需要修改其它代碼,這就是介面編程的優雅之處.
另外的例子就是,在類的方法中,如下聲明:
private void doMyAction(List list){}
這樣這個方法能處理所有實現了List介面的類,一定程度上實現了泛型函數.
3.如果開發的時候覺得ArrayList,HashMap的性能不能滿足你的需要,可以通過實現List,Map(或者Collection)來定製你的自定義類。
❼ Java中Vector和ArrayList的區別
ArrayList和Vector區別如下：
1、ArrayList在內存不夠時默認是擴展50% + 1個，Vector是默認擴展1倍。
2、Vector提供indexOf(obj, start)介面，ArrayList沒有。
3、Vector屬於線程安全級別的，但是大多數情況下不使用Vector，因為線程安全需要更大的系統開銷。
❽ Java中Vector和ArrayList的區別
首先看這兩類都實現List介面，而List介面一共有三個實現類，分別是ArrayList、Vector和LinkedList。List用於存放多個元素，能夠維護元素的次序，並且允許元素的重復。3個具體實現類的相關區別如下：1.ArrayList是最常用的List實現類，內部是通過
❾ vector和list的區別 java
vector是比較老的集合類型,已經被arraylist取代,兩個的主要區別是:
vector是線程同步的,而arraylist不是線程同步,所以使用vector時對對象操作時會安全一點,但是要付出時間和性能的代價.