×

vector和arraylist区别

vector和arraylist区别（ArrayList和vector的区别有哪些）

admin admin 发表于2023-06-22 01:35:09 浏览56 评论0

抢沙发发表评论

本文目录

ArrayList和vector的区别有哪些


一、同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的；
二、数据增长:当需要增长时，Vector默认增长为原来一培，而ArrayList却是原来的一半；
就HashMap与HashTable主要从三方面来说。
一、历史原因：Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现；
二、同步性：Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的；
三、值：只有HashMap可以让空值作为一个表的条目的key或value。

vector和arraylist的区别


Vector与ArrayList的区别:
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.copyOf(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.copyOf(elementData, newCapacity);
}
}
ArrayList和Vector区别如下：
1.ArrayList在内存不够时默认是扩展50% + 1个，Vector是默认扩展1倍。
2.Vector提供indexOf(obj, start)接口，ArrayList没有。
3.Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。

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.arraycopy(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.arraycopy(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。

ArrayList和Vector在使用上有什么区别啊


ArrayList底层是数组实现的，而LinkedList是链表实现的。
Vector和ArrayList一样是数组实现的，二者的差别在于：Vector是线程安全的，所以性能上不如ArrayList
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

arrayList和vector的区别


(1)
Vector比ArrayList先存在。Vector是同步的，Vector的对象是线程安全的；ArrayList是异步的，ArrayList的对象不是线程安全的。同步影响执行效率，所以ArrayList比Vector性能好。
(2)
ArrayList和Vector都有一个初始的容量大小，当存储的空间不够时，需要增加存储空间，Vector默认增长原来的一倍，而ArrayList是原来的0.5倍。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小。

ArrayList和Vector的区别，HashMap和Hashtable的区别


答：就ArrayList与Vector主要从二方面来说.一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半就HashMap与HashTable主要从三方面来说。一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java1.2引进的Map接口的一个实现二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

ArrayList和Vector的区别是什么HashMap和Hashtable的区别呢


ArrayList和Vector都实现了List接口，我们可以分析其源代码，很容易找出它们的区别：
Vector中的add方法如下：
public
synchronized
boolean
add(E
e)
{}
ArrayList中的add方法如下：
public
boolean
add(E
e)
很显然区别就在于一个有synchronized即线程同步，而另一外没有，参考源代码你会发现绝大部分方法都是这样的。
也就是说当存在多线程访问时，Vector比ArrayList要安全，但这种安全的代价就是要付出更多的系统性能
一般情况下我们是使用ArrayList，因为存在多线程去访问同一个list对象的可能性并不是太多。
对于HashMap和Hashtable原理是一样的，Hashtable实现了线程同步，能确保多线程访问时的安全性，性能要比hashMap低

vector和arraylist的区别和联系


vector 安全 arraylist线程不安全
一、从存储数据的方式来看：
1、ArrayList是采用数组方式存储数据，实现了可变大小的数组。
它允许所有元素，包括null。
其特点：
（1）ArrayList没有同步。
（2）此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢。
2、Vector也是采用数组方式存储数据，由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差。
其特点：
（1）Vector是同步的。
（2）由Vector创建的Iterator，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
二、从存取操作的效率来看
在取数据操作中Arraylist最快。
在存数据操作中 linklist最快。
在删除数据操作中linklist最快。
三、从应用的角度来看：
如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。