Java集合(二)ArrayList详解
来源：互联网 发布：淘宝造物节2017图片 编辑：程序博客网 时间：2024/06/01 09:03
（1）ArrayList简介
java.lang.Object ↳ java.util.AbstractCollection<E> ↳ java.util.AbstractList<E> ↳ java.util.ArrayList<E>public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {} ArrayList动态数组，线程不安全，单线程中使用，多线程使用vector或者copyonwritearraylist
ArrayList继承AbstractList，实现了List，提供了添加删除修改遍历等
ArrayList实现了RandomAccess提供了随机访问的功能
ArrayList实现了Cloneable接口，即覆盖了函数clone,能够被克隆
ArrayList实现了Serializable接口，支持序列化，能通过序列化去传输
ArrayList中两个重要的对象：elementData 和 size。
1）elementDate:保存添加到ArrayList中的元素，是一个动态数组，我们通过构造函数可以指定初始化容量，默认容量10，如果需要增长容量，增长规则：新的容量=“(原始容量x3)/2 + 1”
2）size是动态数组的实际大小
（2）ArrayList重点源码分析
ArrayList源码分析(JDk6)
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionUID = 8683452581122892189L; //保存ArrayList中数据的数组 private transient Object[] elementData; //ArrayList的实际数据的数量 private int size; //带容量大小的构造函数 public ArrayList(int initialCapacity) { super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } //默认构造函数，初始化容量值为10 public ArrayList() { this(10); } //创建一个包含collection的ArrayList public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); size = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } //当前容量值=实际元素个数 public void trimToSize() { modCount++; int oldCapacity = elementData.length; if (size < oldCapacity) { elementData = Arrays.copyOf(elementData, size); } } //确定ArrayList的容量，如果ArrayList的容量不足以容纳当前的全部元素，扩容。新的容量=（原始容量*3）/2+1 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); } } //返回当前容量值 public int size() { return size; } //判断ArrayList是否为空 public boolean isEmpty() { return size == 0; } //判断ArrayList是否包含某元素 public boolean contains(Object o) { return indexOf(o) >= 0; } //正向查找是否包含某元素，可以看出ArrayList允许为空元素 public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1; } //反向查找是否包含某元素 public int lastIndexOf(Object o) { if (o == null) { for (int i = size-1; i >= 0; i--) if (elementData[i]==null) return i; } else { for (int i = size-1; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; } //克隆Arraylist public Object clone() { try { ArrayList<E> v = (ArrayList<E>) super.clone(); v.elementData = Arrays.copyOf(elementData, size); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { // this shouldn't happen, since we are Cloneable throw new InternalError(); } } //返回ArrayList的Object数组 public Object[] toArray() { return Arrays.copyOf(elementData, size); } //返回ArrayList的模板数组，如果a的大小<ArrayList的个数，则新建T[],大小为ArrayList的大小，同时将ArrayList全部拷贝到T中 public <T> T[] toArray(T[] a) { if (a.length < size) // Make a new array of a's runtime type, but my contents: return (T[]) Arrays.copyOf(elementData, size, a.getClass()); System.arraycopy(elementData, 0, a, 0, size); if (a.length > size) a[size] = null; return a; } //获取index位置的元素值 public E get(int index) { RangeCheck(index); return (E) elementData[index]; } //设置index位置的元素值为E public E set(int index, E element) { RangeCheck(index); E oldValue = (E) elementData[index]; elementData[index] = element; return oldValue; } //将元素e添加到ArrayList的最后 public boolean add(E e) { ensureCapacity(size + 1); // Increments modCount!! elementData[size++] = e; return true; } //将元素E添加到ArrayList中的index位置 public void add(int index, E element) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); ensureCapacity(size+1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } //移除index的某元素 public E remove(int index) { RangeCheck(index); modCount++; E oldValue = (E) elementData[index]; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work return oldValue; } //移除ArrayList中的某个对象 public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } //快速移除某个位置元素，可以看到快速移除和普通移除的差别在于，不会检测index是否在ArrayList范围内，同时返回值为空 private void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // Let gc do its work } //清除ArrayList中的全部元素，设置为null,说明允许重复 public void clear() { modCount++; // Let gc do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } //将集合C添加到ArrayList中 public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } //将集合C添加到ArrayList中的某个Index位置之后 public boolean addAll(int index, Collection<? extends E> c) { if (index > size || index < 0) throw new IndexOutOfBoundsException( "Index: " + index + ", Size: " + size); Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); // Increments modCount int numMoved = size - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; } //移除区间范围的全部元素 protected void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = size - toIndex; System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved); // Let gc do its work int newSize = size - (toIndex-fromIndex); while (size != newSize) elementData[--size] = null; } //检测index是否在ArrayList范围内 private void RangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); } //将ArrayList的容量，所有元素值都写入到输出流中 private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{ // Write out element count, and any hidden stuff int expectedModCount = modCount; s.defaultWriteObject(); // Write out array length s.writeInt(elementData.length); // Write out all elements in the proper order. for (int i=0; i<size; i++) s.writeObject(elementData[i]); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } //将流中的数据读出 private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in size, and any hidden stuff s.defaultReadObject(); // Read in array length and allocate array int arrayLength = s.readInt(); Object[] a = elementData = new Object[arrayLength]; // Read in all elements in the proper order. for (int i=0; i<size; i++) a[i] = s.readObject(); }}ArrayList源码分析(JDk8)
jdk8中的ArrayList在jdk6的基础上做了很大的改变，但是基本思路是一致的，同样有add,remove,addAll等方法。但是在扩容上做了很大的处理，保证了高效的分配空间，更加合理的处理了ArrayList为空的情况。这里我只列出改动比较大的方法，没有做出全部对比。
//默认容量大小private static final int DEFAULT_CAPACITY = 10;//空数组常量private static final Object[] EMPTY_ELEMENTDATA = {};//默认空数组容量private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//存放元素的数组,transient无法自动序列化，数组内存储的元素其实是一个引用，单单序列化一个引用没有意义，反序列化后这些无法在指向原来的对象transient Object[] elementData;//数组中的元素个数private int size;//数组的最大上限private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; //带容量大小的构造函数，当容量值为0分配空的数组常量，而JDK6中不会考虑数组为空的情况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); }}//空构造函数，不在是创建容量为10的，而是默认的空数组public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}//创建一个包含collection的ArrayListpublic ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; }}//同jdk6中的方法public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); }}//扩容 public void ensureCapacity(int minCapacity) { int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) // any size if not default element table ? 0 // larger than default for default empty table. It's already // supposed to be at default size. : DEFAULT_CAPACITY; if (minCapacity > minExpand) { ensureExplicitCapacity(minCapacity); }}//扩容检测，检测数组大小是否为0，为0，就默认扩容大小10；当数组大小大于当前数组大小时，才进行扩容private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity);}//扩容private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity);}//扩容是真正调用的方法，扩容策略：新容量=原容量大小的1.5倍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);}思考： （1）remove方法中，为什么将数组对应的元素设置为Null？
在remove方法中已经将元素的数量-1了，ArrayList认为该对象已经被移除，应该被jvm回收。但是对于jvm来说，该对象仍然保留在数组中。ArrayList持有这个对象的引用，在JVM发生GC的时候，这个对象是不会被jvm回收，这样会造成内存泄露 （2）查找元素的方法中（比如indexOf），为什么需要对元素进行null值判断
判断对象是否相等，有两个方面。1.对象的存储地址 2.对象的值 ==：判断两个对象的地址是否相等 equals:判断两个对象的值是否相等 对元素进行null值判断，应该是为了效率考虑，如果是Null的话直接比较地址，而是非空，通过equals比较（3）jdk6和jdk8中对于ArrayList的扩容方式：
JDK8：新容量 = 原容量*1.5（先进行大小检测，如果检测大小是0，那么扩容大小是10）JDK6：新容量 = （原容量*3）/2+1（3）ArrayList遍历方式
通过随机访问效率最高，使用迭代器效率最低 1）通过迭代器Iterator遍历
Iterator iter = list.iterator();while(iter.hasNext()){ System.out.print(iter.next());} 2）通过随机访问，通过索引值遍历
Integer value = null;int size = list.size();for (int i=0; i<size; i++) { value = (Integer)list.get(i); } 3）for循环遍历
for(int i = 0; i < stringList.size();i++){ System.out.print(stringList.get(i)); } 阅读全文
0 0
- Java集合(二)ArrayList详解
- Java集合详解-ArrayList
- 【JAVA集合详解】ArrayList
- Java集合-ArrayList 详解
- JAVA集合（二）-ArrayList
- java集合类详解--ArrayList
- java集合框架List之ArrayList(二)
- java集合框架List之ArrayList(二) .
- Java 集合ArrayList与Vector的详解
- Java集合——ArrayList源码详解
- 02、Java集合之ArrayList详解
- 集合详解（二）----ArrayList源代码剖析（JDK1.7）
- 集合详解之ArrayList
- java集合类详解二
- Java集合详解(二)：Map
- Java集合详解（二）
- Java集合类源代码分析二：ArrayList（1）
- Java集合类源代码分析二：ArrayList（2）
- Java读取.ini文件
- java字符串相关常见使用
- 编译Hadoop
- React Native 集成极光推送 JPush出现的一些幺蛾子
- 顺序容器部分习题(基础)
- Java集合(二)ArrayList详解
- 微信支付
- 打印1到最大的n位数
- 打包未签名空包
- 【更新】Word组件Spire.Doc 6.0.41发布 | 支持免费下载
- TimeZone的inDaylightTime(Date date) 和getDSTSavings()方法
- android Intent onNewIntent 什么时候调用
- Running WFSTAT and WFRETRY For Oracle Purchasing Workflows (文档 ID 134960.1)
- Retrofit+Rxjava封装类
