在Java中Vector和ArrayList的区别？？

/
* Resizable-array implementation of the List interface. Implements
* all optional list operations, and permits all elements, including
* null. In addition to implementing the List 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
* Vector, except that it is unsynchronized.)

*
* The size, isEmpty, get, set,
* iterator, and listIterator operations run in constant
* time. The add operation runs in amortized constant time,
* 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 LinkedList implementation.

*
* Each ArrayList instance has a capacity. 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.

*
* An application can increase the capacity of an ArrayList instance
* before adding a large number of elements using the ensureCapacity
* operation. This may reduce the amount of incremental reallocation.

*
* Note that this implementation is not synchronized. If
* multiple threads access an ArrayList instance concurrently, and at
* least one of the threads modifies the list structurally, it must 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 Collections.synchronizedList
* method. This is best done at creation time, to prevent accidental
* unsynchronized access to the list:
*

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

*
* The iterators returned by this class's iterator and
* listIterator methods are fail-fast: 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.
*
*

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 ConcurrentModificationException on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: the fail-fast behavior of iterators
* should be used only to detect bugs.
*
* @author Josh Bloch
* @version 1.36, 12/03/01
* @see Collection
* @see List
* @see LinkedList
* @see Vector
* @see Collections#synchronizedList(List)
* @since 1.2
*/

/
* The Vector 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
* Vector can grow or shrink as needed to accommodate
* adding and removing items after the Vector has been created.

*
* Each vector tries to optimize storage management by maintaining a
* capacity and a capacityIncrement. The
* capacity 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
* capacityIncrement. An application can increase the
* capacity of a vector before inserting a large number of
* components; this reduces the amount of incremental reallocation.

*
* 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.

*
* The Iterators returned by Vector's iterator and listIterator
* methods are fail-fast: 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 not
* fail-fast.
*
*

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 ConcurrentModificationException on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: the fail-fast behavior of iterators
* should be used only to detect bugs.
*
* @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的所开始支持的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.