赞
踩
1)ArrayList集合对象可以添加任意的元素,可以添加null元素,并且可以添加多个null元素;
2)ArrayList是由数组来实现数据存储的;
3)ArrayLiat基本等同于Vector,除了ArrayList是线程不安全的(执行效率高);在多线程情况下不建议使用ArrayList。
- package com.pero.list_;
-
- import java.util.ArrayList;
-
- /**
- * @author Pero
- * @version 1.0
- */
- public class ArrayListDetail {
- public static void main(String[] args) {
-
- //ArrayList线程不安全,源码中方法没有用synchronized修饰
- /*
- * public boolean add(E e) {
- ensureCapacityInternal(size + 1); // Increments modCount!!
- elementData[size++] = e;
- return true;
- }
- * */
-
- ArrayList arrayList = new ArrayList();
-
- //可以添加null
- arrayList.add(null);
- arrayList.add("jack");
- //可以添加多个null
- arrayList.add(null);
- }
- }
1)ArrayList中维护了一个Object类型的数组elementData;
2)当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量为0,第一次添加,则扩容elementData为10,如果需要再次扩容,则扩容elementDate为1.5倍;
3)如果使用的是指定容量大小大的有参构造器,则初始elementData容量为指定大小的值,如果需要扩容,则直接扩容elementData为1.5倍。
- package com.pero.list_;
-
- import java.util.ArrayList;
-
- /**
- * ArrayList的底层操作机制
- *
- * @author Pero
- * @version 1.0
- */
-
- public class ArrayListSource {
- public static void main(String[] args) {
-
- //使用无参构造器创建一个ArrayList对象
- ArrayList arrayList = new ArrayList();
-
- //使用带参数的构造器,给集合赋予初始的空间大小
- //ArrayList arrayList1 = new ArrayList(8);
-
- //使用for给arrayList集合添加1-10数据
- for (int i = 1; i <= 10; i++) {
- arrayList.add(i);
- }
-
- //使用for给arrayList集合添加11-15数据
- for (int i = 11; i <= 15; i++) {
- arrayList.add(i);
- }
-
- arrayList.add(100);
- arrayList.add(200);
- arrayList.add(null);
-
-
- }
- }
- public ArrayList() {
- this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
- }
★elementData的定义:
transient Object[] elementData;
★DEFAULTCAPACITY_EMPTY_ELEMENTDATA的定义:
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
- public static Integer valueOf(int i) {
- if (i >= IntegerCache.low && i <= IntegerCache.high)
- return IntegerCache.cache[i + (-IntegerCache.low)];
- return new Integer(i);
- }
①执行add(E e)方法:(首先进入ensureCapacityInternal(int minCapacity)方法)
- public boolean add(E e) {
- ensureCapacityInternal(size + 1); //确认容量是否足够使用
- elementData[size++] = e; //先将元素e添加进elementData[size]中,然后在执行size++
- return true; //添加成功
- }
②执行ensureCapacityInternal(int minCapacity)方法:(将size + 1 的值以minCapacity形式传进calculateCapacity(Object[] elementData, int minCapacity)方法。)
- private void ensureCapacityInternal(int minCapacity) {
- ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
- }
③执行calculateCapacity(Object[] elementData, int minCapacity)方法:(判断elementData是否为初始定义的空数组,如果是则对DEFAULT_CAPACITY与minCapacity进行比较返回最大的那个值;如果elementData不为初始定义的空数组,则直接返回minCapacity。并将结果传入ensureExplicitCapacity(int minCapacity)方法。)
- private static int calculateCapacity(Object[] elementData, int minCapacity) {
- if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
- return Math.max(DEFAULT_CAPACITY, minCapacity);
- }
- return minCapacity;
- }
private static final int DEFAULT_CAPACITY = 10;
④执行ensureExplicitCapacity(int minCapacity)方法:(首先执行modCount++,是记录集合当前被修改的次数,防止有多个线程同时去修改;然后执行判断minCapacity - elementData.length > 0,意思是如果当前所需求的最小的容量比elementData数组的值要大,那么就要执行grow(minCapacity)方法,对数组进行扩容。)
- private void ensureExplicitCapacity(int minCapacity) {
- modCount++;
-
- // overflow-conscious code
- if (minCapacity - elementData.length > 0)
- grow(minCapacity);
- }
⑤执行grow(int minCapacity)方法:(第一,将原先的elementData数组长度保存为oldCapacity,第二,定义一个新的数组长度newCapacity,大小为老数组长度的1.5倍(oldCapacity + (oldCapacity >> 1),数值右移一位表示原来的数除以二);第三,进行判断newCapacity - minCapacity < 0,如果满足条件则对newCapacity进行重新赋值,例如:无参构造器的elementData初始数组长度为0,0+0/2的值依旧为0,经过判断newCapacity(值为0) - minCapacity(值为10)< 0,然后将minCapacity(值为10)赋值给newCapacity;第四,判断newCapacity的值是否大于MAX_ARRAY_SIZE(值为2147483647),如果满足条件则执行hugeCapacity(minCapacity)方法对newCapacity进行重新赋值,否则执行下一条语句;第五,执行Arrays.copyOf(elementData,newCapacity)方法进行数组拷贝,将原来数组中的数据和扩容后(扩容空间中添加null)再拷贝进elementData数组中。
- private void grow(int minCapacity) {
- // overflow-conscious code
- int oldCapacity = elementData.length;
- int newCapacity = oldCapacity + (oldCapacity >> 1);
- if (newCapacity - minCapacity < 0)
- newCapacity = minCapacity;
- if (newCapacity - MAX_ARRAY_SIZE > 0)
- newCapacity = hugeCapacity(minCapacity);
- // minCapacity is usually close to size, so this is a win:
- elementData = Arrays.copyOf(elementData, newCapacity);
- }
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
- /**
- * A constant holding the maximum value an {@code int} can
- * have, 2的31次方-1.
- */
- @Native public static final int MAX_VALUE = 0x7fffffff;(值为2147483647)
- private static int hugeCapacity(int minCapacity) {
- if (minCapacity < 0) // overflow
- throw new OutOfMemoryError();
- return (minCapacity > MAX_ARRAY_SIZE) ?
- Integer.MAX_VALUE :
- MAX_ARRAY_SIZE;
- }
- public static <T> T[] copyOf(T[] original, int newLength) {
- return (T[]) copyOf(original, newLength, original.getClass());
- }
⑥集合扩容完毕后开始添加元素,执行elementData[size++] = e;然后返回;在容量足够的情况下,执行循环语句。
- public boolean add(E e) {
- ensureCapacityInternal(size + 1); //确认容量是否足够使用
- elementData[size++] = e; //先将元素e添加进elementData[size]中,然后在执行size++
- return true; //添加成功
- }
- public ArrayList(int initialCapacity) {
- if (initialCapacity > 0) {
- this.elementData = new Object[initialCapacity];
- } else if (initialCapacity == 0) {
- this.elementData = EMPTY_ELEMENTDATA;
- } else {
- throw new IllegalArgumentException("Illegal Capacity: "+
- initialCapacity);
- }
- }
- public static Integer valueOf(int i) {
- if (i >= IntegerCache.low && i <= IntegerCache.high)
- return IntegerCache.cache[i + (-IntegerCache.low)];
- return new Integer(i);
- }
①执行add(E e)方法:(首先进入ensureCapacityInternal(int minCapacity)方法)
- public boolean add(E e) {
- ensureCapacityInternal(size + 1); //确认容量是否足够使用
- elementData[size++] = e; //先将元素e添加进elementData[size]中,然后在执行size++
- return true; //添加成功
- }
②执行ensureCapacityInternal(int minCapacity)方法:(将size + 1 的值以minCapacity形式传进calculateCapacity(Object[] elementData, int minCapacity)方法。)
- private void ensureCapacityInternal(int minCapacity) {
- ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
- }
③执行calculateCapacity(Object[] elementData, int minCapacity)方法:(判断elementData是否为初始定义的空数组,如果是则对DEFAULT_CAPACITY与minCapacity进行比较返回最大的那个值;如果elementData不为初始定义的空数组,则直接返回minCapacity。并将结果传入ensureExplicitCapacity(int minCapacity)方法。)
- private static int calculateCapacity(Object[] elementData, int minCapacity) {
- if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
- return Math.max(DEFAULT_CAPACITY, minCapacity);
- }
- return minCapacity;
- }
private static final int DEFAULT_CAPACITY = 10;
④执行ensureExplicitCapacity(int minCapacity)方法:(首先执行modCount++,是记录集合当前被修改的次数,防止有多个线程同时去修改;然后执行判断minCapacity - elementData.length > 0,意思是如果当前所需求的最小的容量比elementData数组的值要大,那么就要执行grow(minCapacity)方法,对数组进行扩容。因为初始化集合容量为8,当传入数据1~7时,不对数组进行扩容,不执行grow(minCapacity)方法。)
- private void ensureExplicitCapacity(int minCapacity) {
- modCount++;
-
- // overflow-conscious code
- if (minCapacity - elementData.length > 0)
- grow(minCapacity);
- }
⑤执行grow(int minCapacity)方法:(第一,将原先的elementData数组长度保存为oldCapacity,第二,定义一个新的数组长度newCapacity,大小为老数组长度的1.5倍(oldCapacity + (oldCapacity >> 1),数值右移一位表示原来的数除以二);第三,进行判断newCapacity - minCapacity < 0,如果满足条件则对newCapacity进行重新赋值,例如:有参构造器指定集合空间为8,扩容后容量为8+4=12>0,不满足条件,执行下一条语句;第四,判断newCapacity的值是否大于MAX_ARRAY_SIZE(值为2147483647),如果满足条件则执行hugeCapacity(minCapacity)方法对newCapacity进行重新赋值,否则执行下一条语句;第五,执行Arrays.copyOf(elementData,newCapacity)方法进行数组拷贝,将原来数组中的数据和扩容后(扩容空间中添加null)再拷贝进elementData数组中。
- private void grow(int minCapacity) {
- // overflow-conscious code
- int oldCapacity = elementData.length;
- int newCapacity = oldCapacity + (oldCapacity >> 1);
- if (newCapacity - minCapacity < 0)
- newCapacity = minCapacity;
- if (newCapacity - MAX_ARRAY_SIZE > 0)
- newCapacity = hugeCapacity(minCapacity);
- // minCapacity is usually close to size, so this is a win:
- elementData = Arrays.copyOf(elementData, newCapacity);
- }
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
- /**
- * A constant holding the maximum value an {@code int} can
- * have, 2的31次方-1.
- */
- @Native public static final int MAX_VALUE = 0x7fffffff;(值为2147483647)
- private static int hugeCapacity(int minCapacity) {
- if (minCapacity < 0) // overflow
- throw new OutOfMemoryError();
- return (minCapacity > MAX_ARRAY_SIZE) ?
- Integer.MAX_VALUE :
- MAX_ARRAY_SIZE;
- }
- public static <T> T[] copyOf(T[] original, int newLength) {
- return (T[]) copyOf(original, newLength, original.getClass());
- }
⑥集合扩容完毕后开始添加元素,执行elementData[size++] = e;然后返回;在容量足够的情况下,执行循环语句。
- public boolean add(E e) {
- ensureCapacityInternal(size + 1); //确认容量是否足够使用
- elementData[size++] = e; //先将元素e添加进elementData[size]中,然后在执行size++
- return true; //添加成功
- }
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。