在Java中Vector和ArrayList的区别??

在Java中Vector和ArrayList有何区别?
那么,分别是在什么场合下使用它.有什么优,缺点??

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 CollectionssynchronizedList(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


其实我觉得你的问题应该是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.

Vector是有信号量的,可以同步锁,ArrayList没有,所以相对来说ArrayList的存取速度比Vector快。
同理HashMap比Hashtable快

刚刚学到的,这个题目在以前面试的时候遇到过,可惜没能很好的回答出来。
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)。