在Java中Vector和ArrayList的区别??

04-01-31 jeff_yuchang
在Java中Vector和ArrayList有何区别?

那么,分别是在什么场合下使用它.有什么优,缺点??

wildfox
2004-02-02 14:37
java 的文档,自己看吧

/**

* Resizable-array implementation of the <tt>List</tt> interface. Implements

* all optional list operations, and permits all elements, including

* <tt>null</tt>. In addition to implementing the <tt>List</tt> interface,

* this class provides methods to manipulate the size of the array that is

* used internally to store the list. (This class is roughly equivalent to

* <tt>Vector</tt>, except that it is unsynchronized.)<p>

*

* The <tt>size</tt>, <tt>isEmpty</tt>, <tt>get</tt>, <tt>set</tt>,

* <tt>iterator</tt>, and <tt>listIterator</tt> operations run in constant

* time. The <tt>add</tt> operation runs in <i>amortized constant time</i>,

* that is, adding n elements requires O(n) time. All of the other operations

* run in linear time (roughly speaking). The constant factor is low compared

* to that for the <tt>LinkedList</tt> implementation.<p>

*

* Each <tt>ArrayList</tt> instance has a <i>capacity</i>. The capacity is

* the size of the array used to store the elements in the list. It is always

* at least as large as the list size. As elements are added an ArrayList,

* its capacity grows automatically. The details of the growth policy are not

* specified beyond the fact that adding an element has constant amortized

* time cost.<p>

*

* An application can increase the capacity of an <tt>ArrayList</tt> instance

* before adding a large number of elements using the <tt>ensureCapacity</tt>

* operation. This may reduce the amount of incremental reallocation.<p>

*

* <strong>Note that this implementation is not synchronized.</strong> If

* multiple threads access an <tt>ArrayList</tt> instance concurrently, and at

* least one of the threads modifies the list structurally, it <i>must</i> be

* synchronized externally. (A structural modification is any operation that

* adds or deletes one or more elements, or explicitly resizes the backing

* array; merely setting the value of an element is not a structural

* modification.) This is typically accomplished by synchronizing on some

* object that naturally encapsulates the list. If no such object exists, the

* list should be "wrapped" using the <tt>Collections.synchronizedList</tt>

* method. This is best done at creation time, to prevent accidental

* unsynchronized access to the list:

* <pre>

* List list = Collections.synchronizedList(new ArrayList(...));

* </pre><p>

*

* The iterators returned by this class's <tt>iterator</tt> and

* <tt>listIterator</tt> methods are <i>fail-fast</i>: if list is structurally

* modified at any time after the iterator is created, in any way except

* through the iterator's own remove or add methods, the iterator will throw a

* ConcurrentModificationException. Thus, in the face of concurrent

* modification, the iterator fails quickly and cleanly, rather than risking

* arbitrary, non-deterministic behavior at an undetermined time in the

* future.

*

* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed

* as it is, generally speaking, impossible to make any hard guarantees in the

* presence of unsynchronized concurrent modification. Fail-fast iterators

* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.

* Therefore, it would be wrong to write a program that depended on this

* exception for its correctness: <i>the fail-fast behavior of iterators

* should be used only to detect bugs.</i>

*

* @author Josh Bloch

* @version 1.36, 12/03/01

* @see Collection

* @see List

* @see LinkedList

* @see Vector

* @see Collections#synchronizedList(List)

* @since 1.2

*/

public class ArrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable;

/**

* The <code>Vector</code> class implements a growable array of

* objects. Like an array, it contains components that can be

* accessed using an integer index. However, the size of a

* <code>Vector</code> can grow or shrink as needed to accommodate

* adding and removing items after the <code>Vector</code> has been created.<p>

*

* Each vector tries to optimize storage management by maintaining a

* <code>capacity</code> and a <code>capacityIncrement</code>. The

* <code>capacity</code> is always at least as large as the vector

* size; it is usually larger because as components are added to the

* vector, the vector's storage increases in chunks the size of

* <code>capacityIncrement</code>. An application can increase the

* capacity of a vector before inserting a large number of

* components; this reduces the amount of incremental reallocation. <p>

*

* As of the Java 2 platform v1.2, this class has been retrofitted to

* implement List, so that it becomes a part of Java's collection framework.

* Unlike the new collection implementations, Vector is synchronized.<p>

*

* The Iterators returned by Vector's iterator and listIterator

* methods are <em>fail-fast</em>: if the Vector is structurally modified

* at any time after the Iterator is created, in any way except through the

* Iterator's own remove or add methods, the Iterator will throw a

* ConcurrentModificationException. Thus, in the face of concurrent

* modification, the Iterator fails quickly and cleanly, rather than risking

* arbitrary, non-deterministic behavior at an undetermined time in the future.

* The Enumerations returned by Vector's elements method are <em>not</em>

* fail-fast.

*

* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed

* as it is, generally speaking, impossible to make any hard guarantees in the

* presence of unsynchronized concurrent modification. Fail-fast iterators

* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.

* Therefore, it would be wrong to write a program that depended on this

* exception for its correctness: <i>the fail-fast behavior of iterators

* should be used only to detect bugs.</i>

*

* @author Lee Boynton

* @author Jonathan Payne

* @version 1.85, 12/03/01

* @see Collection

* @see List

* @see ArrayList

* @see LinkedList

* @since JDK1.0

*/

public class Vector extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

jrog
2004-02-03 17:41
其实我觉得你的问题应该是Vector和List的区别

如果你注意到对Vector和List的所开始支持的Java版本你就应该可以找到答案了。Java对Vector的支持since 1.0;对List则是since 1.2。这两个版本之间,sun对于java api做了很多的改动,其中的一个refactoring就是提出了所谓的Collection FrameWork,List就是在那个时候被introduced,它完全符合1.2版本的collection framework,而Vector则是在Colleciton framework出现之前就已经存在了,但java api并没有将Vector变成Deprecated,主要是backward compatiable的问题,最终JCP将vector做了refactoring的处理,让它符合所定制的Collection framework了事。另外,Hashtable和HashMap的区别是同样的道理。

结论:尽量采用List和HashMap,rather than Vector&Hashtable.

nhk
2004-02-05 15:19
Vector是有信号量的,可以同步锁,ArrayList没有,所以相对来说ArrayList的存取速度比Vector快。

同理HashMap比Hashtable快

kookooer
2005-09-23 08:25
刚刚学到的,这个题目在以前面试的时候遇到过,可惜没能很好的回答出来。

1,vector是线程同步的,所以它也是线程安全的,而arraylist是线程异步的,是不安全的。如果不考虑到线程的安全因素,一般用arraylist效率比较高。

2,如果集合中的元素的数目大于目前集合数组的长度时,vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据,用vector有一定的优势。

3,如果查找一个指定位置的数据,vector和arraylist使用的时间是相同的,都是0(1),这个时候使用vector和arraylist都可以。而如果移动一个指定位置的数据花费的时间为0(n-i)n为总长度,这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据所花费的时间为0(1),而查询一个指定位置的数据时花费的时间为0(i)。

猜你喜欢