ArrayList和Vector

当前位置:

ArrayList

1.ArrayList可以加入null，并且多个

2.ArrayList是由数组来实现数据存储的

3.ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高）。在多线程情况下，不建议使用ArrayList

1.arrayList中维护了一个Object类型的数组elementData。【debug看源码】transient Object[] elementData;//transient 表示瞬间，短暂的，表示该属性不会被序列化

2.当创建ArrayList对象时，如果使用无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如果需要再次扩容，则扩容elementData为1.5倍

3.如果使用的是指定大小的构造器，则初始elementData容量指定大小，如果需要扩容，则直接扩容elementData为1.5倍。

debug调试以下代码，查看源码

	import java.util.ArrayList;

	@SuppressWarnings({"all"})
	public class ArrayListSource {
	public static void main(String[] args) {
	//解读源码
	//注意，注意，注意，Idea 默认情况下，Debug 显示的数据是简化后的，如果希望看到完整的数据
	//需要做设置. //使用无参构造器创建 ArrayList 对象
	//ArrayList list = new ArrayList();
	ArrayList list = new ArrayList(8);
	//使用 for 给 list 集合添加 1-10 数据
	for (int i = 1; i <= 10; i++) {
	list.add(i);
	}
	//使用 for 给 list 集合添加 11-15 数据
	for (int i = 11; i <= 15; i++) {
	list.add(i);
	}
	list.add(100);
	list.add(200);
	list.add(null);
	}
	}

1.Vector类的定义说明：

	public class Vector<E> extens AbstractList<E> implements List<E>,RandomAccess,Cloneable,Serializable

2.Vector 底层也是一个对象数组

3.Vector是线程同步的，即线程安全，Vector类的操作方法带有 synchronized

4.在开发中，需要线程同步安全时，考虑使用Vector

	package List_.Vector_;

	import java.util.Vector;
	@SuppressWarnings({"all"})
	public class Vector_ {
	public static void main(String[] args) {
	//无参构造器
	//有参数的构造
	Vector vector = new Vector(8);
	for (int i = 0; i < 10; i++) {
	vector.add(i);
	}
	vector.add(100);
	System.out.println("vector=" + vector);
	//解读源码
	//1. new Vector() 底层
	/*
	public Vector() {
	this(10);
	}
	补充：如果是 Vector vector = new Vector(8);
	走的方法:
	public Vector(int initialCapacity) {
	this(initialCapacity, 0);
	}
	2. vector.add(i)
	2.1 //下面这个方法就添加数据到 vector 集合
	public synchronized boolean add(E e) {
	modCount++;
	ensureCapacityHelper(elementCount + 1);
	elementData[elementCount++] = e;
	return true;
	}
	2.2 //确定是否需要扩容条件： minCapacity - elementData.length>0
	private void ensureCapacityHelper(int minCapacity) {
	// overflow-conscious code
	if (minCapacity - elementData.length > 0
	grow(minCapacity);
	}
	2.3 //如果需要的数组大小不够用，就扩容 , 扩容的算法
	//newCapacity = oldCapacity + ((capacityIncrement > 0) ?
	// capacityIncrement : oldCapacity);
	//就是扩容两倍.
	private void grow(int minCapacity) {
	// overflow-conscious code
	int oldCapacity = elementData.length;
	int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
	capacityIncrement : oldCapacity);
	if (newCapacity - minCapacity < 0)
	newCapacity = minCapacity;
	if (newCapacity - MAX_ARRAY_SIZE > 0)
	newCapacity = hugeCapacity(minCapacity);
	elementData = Arrays.copyOf(elementData, newCapacity);
	}
	*/
	}
	}

	ArrayList	Vector
底层结构	可变数组	可变数组
版本	jdk1.2	jdk1.0
线程安全（同步效率）	不安全，效率高	安全，效率不高
扩容倍数	如果有参构造1.5倍。如果是无参：1.第一次10；2.从第二次开始按1.5扩	如果是无参，默认10，满后，就按2倍扩容。如果指定大小，则每次直接按2倍扩容

__EOF__

本文作者：Anesthesi 本文链接：https://www.cnblogs.com/Anesthesi/p/15435054.html

栏目列表