ArrayList
2016-05-05 20:39
369 查看
ArrayList
ArrayList概述
成员变量
构造器
成员方法
Summary
概述
ArrayList是List接口的具体实现类,可以存储任何元素,包括null。这个类与Vector类几乎是一样的,仅有的区别就是Vector类是线程安全的(方法有synchronized关键字),而ArrayList不是。关于时间复杂度:
constant time
size, isEmpty, get, set, iterator, listIterator
amortized constant time
add(也就是说,添加n个元素,需要O(n)时间)
linear time
other operations
关于线程安全:
ArrayList不是线程安全的
如果多个线程同时访问一个ArrayList实例,并且至少一个线程对ArrayList进行了structural modification(结构化修改,顾名思义,就是修改了结构发生了变化,是说添加或者是删除了一个或多个元素,如果仅仅是修改了元素的值,则不是结构化修改),那么必须在外部syncronized(使用ArrayList的地方synchronized)。
有时候,也会通过以下用法来达到ArrayList的线程安全
List list = Collections.synchronizedList(new ArrayList(...))
关于fast-fail:
ArrayList的iterator()和listIterator()方法返回的iterator,具有fast-fail的特点,也就是说,在iterator创建后,不允许list的结构发生变化(add/remove),否则会抛出ConcurrentModificationException异常。
成员变量
private static final long serialVersionUID = 8683452581122892189L; /* 默认容量 */ private static final int DEFAULT_CAPACITY = 10; /* 所有的空实例共享的空数组 */ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * 这个空数组是为了与EMPTY_ELEMENTDATA区别开来,后者是当ArrayList * 的capacity为0时使用的(比如用来ArrayList(0)这个构造器),而 * DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是给有默认长度的空数组使用的 * 它还可以用来判断容量需要增加多少(见ensureCapacity()方法) */ private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * 这个数组就是ArrayList存储数据的地方啦 * 它的长度就是数组的capacity。 * 任何elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA * 的ArrayList,当第一个元素添加进来的时候,capacity自动增大为 * DEFAULT_CAPACITY */ transient Object[] elementData; /*List大小,也即当前数组中元素的数目*/ private int size;
构造器
/** * 如果initialCapacity为0,就用EMPTY_ELEMENTDATA */ 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); } } /** * 没有指定initialCapacity,就用DEFAULTCAPACITY_EMPTY_ELEMENTDATA * 这样当第一个数据添加进来的时候,size自动变为DEFAULT_CAPACITY */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } /** * 利用一个Collection构造一个ArrayList * 先把Collection变为Array */ public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // 注意这里,如果elementData的类型不是Object,那么用Array.copyOf变为Object if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // size为0,空数组 this.elementData = EMPTY_ELEMENTDATA; } }
成员方法
/** * 把ArrayList的capacity“剪”成size大小,节省空间 */ public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } } /** * 增加ArrayList的capacity, 到底能不能增加,还要看情况 * */ public void ensureCapacity(int minCapacity) { int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) // 如果不相等,那么可以expand任意大小 ? 0 // 如果相等,那么说明现在的capacity已经是 DEFAULT_CAPACITY了 : DEFAULT_CAPACITY; // 如果比需要增大的最小值还小,那么什么都不做 if (minCapacity > minExpand) { ensureExplicitCapacity(minCapacity); } } // 内部方法,主要是给add用的 private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // 防止溢出 if (minCapacity - elementData.length > 0) grow(minCapacity); } private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; /** * expand capacity */ private void grow(int minCapacity) { // 注意溢出 int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); // 每次扩大1.5倍 if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // 比最大数组大小还大!! elementData = Arrays.copyOf(elementData, newCapacity); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } public int size() { return size; } public boolean isEmpty() { return size == 0; } public boolean contains(Object o) { return indexOf(o) >= 0; } /** * 返回元素在List中第一次出现的索引值,或者是-1(如果没找到) * 就算Object为null,也会进行查找~~ */ 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; } /** * 与indexOf()方向相反 */ 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<?> v = (ArrayList<?>) super.clone(); v.elementData = Arrays.copyOf(elementData, size); v.modCount = 0; return v; } catch (CloneNotSupportedException e) { throw new InternalError(e); } } /** * 浅拷贝 ☆ */ public Object[] toArray() { return Arrays.copyOf(elementData, size); } /** * 返回一个包含了本ArrayList所有元素的数组,如果a的长度不小于ArrayList的长度 * 那么元素就保存在a中,否则,就重新创建一个新的数组,返回... */ @SuppressWarnings("unchecked") 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; } @SuppressWarnings("unchecked") E elementData(int index) { return (E) elementData[index]; } public E get(int index) { rangeCheck(index); return elementData(index); } public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; } public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } /** * 在给定的index处添加元素,那么index后面的元素都要后移,可见效率不高 */ public void add(int index, E element) { rangeCheckForAdd(index); ensureCapacityInternal(size + 1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } /** * 删除给定index处的元素,index后的元素都要前移,效率不高 */ public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // clear to let GC do its work return oldValue; } /** * 删除在ArrayList中第一次出现o的地方,注意null也合法 */ 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合法,所以才敢这么干 */ 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; // clear to let GC do its work } public void clear() { modCount++; // 都设置为null,让垃圾收集器回收 for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } /** * 把Collection c变成Array再添加到ArrayList的尾部,如果c中途有变化,则结果不确定 */ public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); Object[] a = c.toArray(); int numNew = a.length; ensureCapacityInternal(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); // clear to let GC do its work int newSize = size - (toIndex-fromIndex); for (int i = newSize; i < size; i++) { elementData[i] = null; } size = newSize; } private void rangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } /** * A version of rangeCheck used by add and addAll. */ private void rangeCheckForAdd(int index) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } private String outOfBoundsMsg(int index) { return "Index: "+index+", Size: "+size; } public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); return batchRemove(c, false); } /** * 保留c中的所有元素,也就是删除所有不是c中的元素 */ public boolean retainAll(Collection<?> c) { Objects.requireNonNull(c); return batchRemove(c, true); } /** * 批量删除 */ private boolean batchRemove(Collection<?> c, boolean complement) { final Object[] elementData = this.elementData; // w是符合条件的索引值,r是原始数据的索引 int r = 0, w = 0; boolean modified = false; try { for (; r < size; r++) if (c.contains(elementData[r]) == complement) elementData[w++] = elementData[r]; } finally { // 发生r != size的情况应该是发生异常了,依然拷贝剩下的size - r个元素 if (r != size) { System.arraycopy(elementData, r, elementData, w, size - r); w += size - r; } // w == size说明所有元素都符合条件,不用动,否则要把w后面的元素置为null if (w != size) { // clear to let GC do its work for (int i = w; i < size; i++) elementData[i] = null; modCount += size - w; size = w; modified = true; } } return modified; } /** * 序列化ArrayList实例的状态 * 这里就能看出为什么elementData[] 设置为transient了,因为要保存的是值,而不是数组首地址 */ 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 size as capacity for behavioural compatibility with clone() s.writeInt(size); // 保存的是元素的值. 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 { elementData = EMPTY_ELEMENTDATA; // Read in size, and any hidden stuff s.defaultReadObject(); // Read in capacity s.readInt(); // ignored if (size > 0) { // be like clone(), allocate array based upon size not capacity ensureCapacityInternal(size); Object[] a = elementData; // Read in all elements in the proper order. for (int i=0; i<size; i++) { a[i] = s.readObject(); } } } /** * 返回一个list迭代器,迭代器的初始指向位置是index * index不写,就是0 */ public ListIterator<E> listIterator(int index) { if (index < 0 || index > size) throw new IndexOutOfBoundsException("Index: "+index); return new ListItr(index); } public ListIterator<E> listIterator() { return new ListItr(0); } public Iterator<E> iterator() { return new Itr(); } /** * An optimized version of AbstractList.Itr */ private class Itr implements Iterator<E> { int cursor; // 下一个元素的索引 int lastRet = -1; // 最后一个返回的元素的索引,没有就是-1 int expectedModCount = modCount; public boolean hasNext() { return cursor != size; // cursor == size了,说明已经到底了 } // 可见next()是先返回当前位置的值,再把cursor往后移动一位 @SuppressWarnings("unchecked") public E next() { checkForComodification(); int i = cursor; // cursor是下一个元素的索引值 if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; // cursor向后移动一位 return (E) elementData[lastRet = i]; // lastRet设置为i,并且把i处的元素返回 } public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { // 删除的是最后一次返回的值,注意调用的是ArrayList的remove()方法 ArrayList.this.remove(lastRet); cursor = lastRet; // 下一个元素的位置变成了lastRet lastRet = -1; // 表明不能连续删除两次 expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } @Override @SuppressWarnings("unchecked") // jdk1.8特有的,函数式接口Consumer ☆ public void forEachRemaining(Consumer<? super E> consumer) { Objects.requireNonNull(consumer); final int size = ArrayList.this.size; int i = cursor; // 下一个元素的索引 if (i >= size) { return; } final Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) { throw new ConcurrentModificationException(); } // 当前位置后面的所有元素都交给了comsumer接口中的accept抽象方法 while (i != size && modCount == expectedModCount) { consumer.accept((E) elementData[i++]); } // update once at end of iteration to reduce heap write traffic cursor = i; lastRet = i - 1; checkForComodification(); } final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } } /** * An optimized version of AbstractList.ListItr * 继承Itr,实现了ListIterator,多了一些previous等方法 * 要记得,iterator的操作,与当前指向的位置很重要,切记 */ private class ListItr extends Itr implements ListIterator<E> { ListItr(int index) { super(); cursor = index; } public boolean hasPrevious() { return cursor != 0; // cursor == 0说明没有前一个元素了 } public int nextIndex() { return cursor; } public int previousIndex() { return cursor - 1; } @SuppressWarnings("unchecked") public E previous() { checkForComodification(); int i = cursor - 1; if (i < 0) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); // previous()方法会让cursor发生移动 cursor = i; return (E) elementData[lastRet = i]; } public void set(E e) { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { // 调用的是外部类的set方法,复用 ArrayList.this.set(lastRet, e); } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } public void add(E e) { checkForComodification(); try { int i = cursor; ArrayList.this.add(i, e); // cursor后移,这个add可不是在尾端添加,只会在iterator指向的当前添加 cursor = i + 1; // 说明add后不能够remove lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } } /** * 返回ArrayList的一部分 */ public List<E> subList(int fromIndex, int toIndex) { subListRangeCheck(fromIndex, toIndex, size); // this就是subList的parent return new SubList(this, 0, fromIndex, toIndex); } static void subListRangeCheck(int fromIndex, int toIndex, int size) { if (fromIndex < 0) throw new IndexOutOfBoundsException("fromIndex = " + fromIndex); if (toIndex > size) throw new IndexOutOfBoundsException("toIndex = " + toIndex); if (fromIndex > toIndex) throw new IllegalArgumentException("fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")"); } // 整个SubList类具有的方法和ArrayList类似 private class SubList extends AbstractList<E> implements RandomAccess { private final AbstractList<E> parent; private final int parentOffset; private final int offset; int size; SubList(AbstractList<E> parent, int offset, int fromIndex, int toIndex) { this.parent = parent; this.parentOffset = fromIndex; this.offset = offset + fromIndex; this.size = toIndex - fromIndex; this.modCount = ArrayList.this.modCount; } // 会修改parent的数据 public E set(int index, E e) { rangeCheck(index); checkForComodification(); E oldValue = ArrayList.this.elementData(offset + index); ArrayList.this.elementData[offset + index] = e; return oldValue; } public E get(int index) { rangeCheck(index); checkForComodification(); return ArrayList.this.elementData(offset + index); } public int size() { checkForComodification(); return this.size; } // 会修改parent的数据 public void add(int index, E e) { rangeCheckForAdd(index); checkForComodification(); parent.add(parentOffset + index, e); this.modCount = parent.modCount; this.size++; } // 不知道为什么一会儿用ArrayList.this,一会儿用parent,这两者不是一样的吗? public E remove(int index) { rangeCheck(index); checkForComodification(); E result = parent.remove(parentOffset + index); this.modCount = parent.modCount; this.size--; return result; } // 会修改parent的数据 protected void removeRange(int fromIndex, int toIndex) { checkForComodification(); parent.removeRange(parentOffset + fromIndex, parentOffset + toIndex); this.modCount = parent.modCount; this.size -= toIndex - fromIndex; } // 会修改parent的数据 public boolean addAll(Collection<? extends E> c) { return addAll(this.size, c); } // 会修改parent的数据 public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); int cSize = c.size(); if (cSize==0) return false; checkForComodification(); parent.addAll(parentOffset + index, c); this.modCount = parent.modCount; this.size += cSize; return true; } public Iterator<E> iterator() { return listIterator(); } public ListIterator<E> listIterator(final int index) { checkForComodification(); rangeCheckForAdd(index); final int offset = this.offset; return new ListIterator<E>() { int cursor = index; int lastRet = -1; int expectedModCount = ArrayList.this.modCount; public boolean hasNext() { return cursor != SubList.this.size; } @SuppressWarnings("unchecked") public E next() { checkForComodification(); int i = cursor; if (i >= SubList.this.size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (offset + i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; return (E) elementData[offset + (lastRet = i)]; } public boolean hasPrevious() { return cursor != 0; } @SuppressWarnings("unchecked") public E previous() { checkForComodification(); int i = cursor - 1; if (i < 0) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (offset + i >= elementData.length) throw new ConcurrentModificationException(); cursor = i; return (E) elementData[offset + (lastRet = i)]; } // 好像与ArrayList#forEachRemaining()不一样?☆ @SuppressWarnings("unchecked") public void forEachRemaining(Consumer<? super E> consumer) { Objects.requireNonNull(consumer); final int size = SubList.this.size; int i = cursor; if (i >= size) { return; } final Object[] elementData = ArrayList.this.elementData; if (offset + i >= elementData.length) { throw new ConcurrentModificationException(); } while (i != size && modCount == expectedModCount) { consumer.accept((E) elementData[offset + (i++)]); } // update once at end of iteration to reduce heap write traffic lastRet = cursor = i; checkForComodification(); } public int nextIndex() { return cursor; } public int previousIndex() { return cursor - 1; } public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { SubList.this.remove(lastRet); cursor = lastRet; lastRet = -1; expectedModCount = ArrayList.this.modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } public void set(E e) { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { ArrayList.this.set(offset + lastRet, e); } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } public void add(E e) { checkForComodification(); try { int i = cursor; SubList.this.add(i, e); cursor = i + 1; lastRet = -1; expectedModCount = ArrayList.this.modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } final void checkForComodification() { if (expectedModCount != ArrayList.this.modCount) throw new ConcurrentModificationException(); } }; } // SubList类中subList方法 public List<E> subList(int fromIndex, int toIndex) { subListRangeCheck(fromIndex, toIndex, size); return new SubList(this, offset, fromIndex, toIndex); } private void rangeCheck(int index) { if (index < 0 || index >= this.size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } private void rangeCheckForAdd(int index) { if (index < 0 || index > this.size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } private String outOfBoundsMsg(int index) { return "Index: "+index+", Size: "+this.size; } private void checkForComodification() { if (ArrayList.this.modCount != this.modCount) throw new ConcurrentModificationException(); } public Spliterator<E> spliterator() { checkForComodification(); return new ArrayListSpliterator<E>(ArrayList.this, offset, offset + this.size, this.modCount); } } // forEachRemaining()的特例 @Override public void forEach(Consumer<? super E> action) { Objects.requireNonNull(action); final int expectedModCount = modCount; @SuppressWarnings("unchecked") final E[] elementData = (E[]) this.elementData; final int size = this.size; for (int i=0; modCount == expectedModCount && i < size; i++) { action.accept(elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } /** * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em> * and <em>fail-fast</em> {@link Spliterator} over the elements in this * list. * * <p>The {@code Spliterator} reports {@link Spliterator#SIZED}, * {@link Spliterator#SUBSIZED}, and {@link Spliterator#ORDERED}. * Overriding implementations should document the reporting of additional * characteristic values. * * @return a {@code Spliterator} over the elements in this list * @since 1.8 */ @Override public Spliterator<E> spliterator() { return new ArrayListSpliterator<>(this, 0, -1, 0); } /** Index-based split-by-two, lazily initialized Spliterator */ static final class ArrayListSpliterator<E> implements Spliterator<E> { /* * If ArrayLists were immutable, or structurally immutable (no * adds, removes, etc), we could implement their spliterators * with Arrays.spliterator. Instead we detect as much * interference during traversal as practical without * sacrificing much performance. We rely primarily on * modCounts. These are not guaranteed to detect concurrency * violations, and are sometimes overly conservative about * within-thread interference, but detect enough problems to * be worthwhile in practice. To carry this out, we (1) lazily * initialize fence and expectedModCount until the latest * point that we need to commit to the state we are checking * against; thus improving precision. (This doesn't apply to * SubLists, that create spliterators with current non-lazy * values). (2) We perform only a single * ConcurrentModificationException check at the end of forEach * (the most performance-sensitive method). When using forEach * (as opposed to iterators), we can normally only detect * interference after actions, not before. Further * CME-triggering checks apply to all other possible * violations of assumptions for example null or too-small * elementData array given its size(), that could only have * occurred due to interference. This allows the inner loop * of forEach to run without any further checks, and * simplifies lambda-resolution. While this does entail a * number of checks, note that in the common case of * list.stream().forEach(a), no checks or other computation * occur anywhere other than inside forEach itself. The other * less-often-used methods cannot take advantage of most of * these streamlinings. */ private final ArrayList<E> list; private int index; // current index, modified on advance/split private int fence; // -1 until used; then one past last index private int expectedModCount; // initialized when fence set /** Create new spliterator covering the given range */ ArrayListSpliterator(ArrayList<E> list, int origin, int fence, int expectedModCount) { this.list = list; // OK if null unless traversed this.index = origin; this.fence = fence; this.expectedModCount = expectedModCount; } private int getFence() { // initialize fence to size on first use int hi; // (a specialized variant appears in method forEach) ArrayList<E> lst; if ((hi = fence) < 0) { if ((lst = list) == null) hi = fence = 0; else { expectedModCount = lst.modCount; hi = fence = lst.size; } } return hi; } public ArrayListSpliterator<E> trySplit() { int hi = getFence(), lo = index, mid = (lo + hi) >>> 1; return (lo >= mid) ? null : // divide range in half unless too small new ArrayListSpliterator<E>(list, lo, index = mid, expectedModCount); } public boolean tryAdvance(Consumer<? super E> action) { if (action == null) throw new NullPointerException(); int hi = getFence(), i = index; if (i < hi) { index = i + 1; @SuppressWarnings("unchecked") E e = (E)list.elementData[i]; action.accept(e); if (list.modCount != expectedModCount) throw new ConcurrentModificationException(); return true; } return false; } public void forEachRemaining(Consumer<? super E> action) { int i, hi, mc; // hoist accesses and checks from loop ArrayList<E> lst; Object[] a; if (action == null) throw new NullPointerException(); if ((lst = list) != null && (a = lst.elementData) != null) { if ((hi = fence) < 0) { mc = lst.modCount; hi = lst.size; } else mc = expectedModCount; if ((i = index) >= 0 && (index = hi) <= a.length) { for (; i < hi; ++i) { @SuppressWarnings("unchecked") E e = (E) a[i]; action.accept(e); } if (lst.modCount == mc) return; } } throw new ConcurrentModificationException(); } public long estimateSize() { return (long) (getFence() - index); } public int characteristics() { return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED; } } // Predicate中 test方法返回boolean值,为true则remove @Override public boolean removeIf(Predicate<? super E> filter) { Objects.requireNonNull(filter); // figure out which elements are to be removed // any exception thrown from the filter predicate at this stage // will leave the collection unmodified int removeCount = 0; // 使用BitSet保存filter.test()为true的index,巧妙 final BitSet removeSet = new BitSet(size); final int expectedModCount = modCount; final int size = this.size; for (int i=0; modCount == expectedModCount && i < size; i++) { @SuppressWarnings("unchecked") final E element = (E) elementData[i]; if (filter.test(element)) { removeSet.set(i); // 如果符合过滤条件,则index位置为true removeCount++; } } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } // shift surviving elements left over the spaces left by removed elements final boolean anyToRemove = removeCount > 0; if (anyToRemove) { final int newSize = size - removeCount; // 剩下的元素数目 for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) { // 寻找从i开始第一个bit位为false的位置,为false,表明不需要删除,保存起来 i = removeSet.nextClearBit(i); elementData[j] = elementData[i]; } for (int k=newSize; k < size; k++) { elementData[k] = null; // 剩余的元素都设为null,垃圾回收 } this.size = newSize; if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } return anyToRemove; } // UnaryOperator中的apply方法应用到所有元素上 @Override @SuppressWarnings("unchecked") public void replaceAll(UnaryOperator<E> operator) { Objects.requireNonNull(operator); final int expectedModCount = modCount; final int size = this.size; for (int i=0; modCount == expectedModCount && i < size; i++) { elementData[i] = operator.apply((E) elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } // 利用Arrays工具类排序 @Override @SuppressWarnings("unchecked") public void sort(Comparator<? super E> c) { final int expectedModCount = modCount; Arrays.sort((E[]) elementData, 0, size, c); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } }
Summary☆☆☆☆☆
ArrayList#clone() 和 ArrayList#toArray()package com.stephen.collection; import java.util.ArrayList; public class ArrayListTest { @SuppressWarnings("unchecked") public static void main(String[] args) { ArrayList<Person> al = new ArrayList<>(); al.add(new Person("zhangsan", 1)); al.add(new Person("lisi", 2)); al.add(new Person("wangwu", 3)); ArrayList<Person> al2 = (ArrayList<Person>) al.clone(); // Object[] al2 = al.toArray(); System.out.println(al.get(0) == al2.get(0)); // System.out.println(al2[0] == al.get(0)); } } class Person { private String name; public Person(String name, int age) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Person [name=" + name + "]"; } } // output,shallow copy true
Arrays#copyOf()和System#arraycopy()
/** * copyOf()调用了arraycopy() * copyOf()的参数是: 源数组,新数组长度,以及新数组中的元素类型;返回新数组 * arraycopy()的参数是: 源数组,源数组起始index,目的数组,目的数组index;无返回值 * 能用arraycopy()尽量用arraycopy() */ public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { @SuppressWarnings("unchecked") T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }
SubList类
可以看出SubList类中很多方法都会修改parent List,所以使用的时候要小心。
FunctionalInterface
JDK8新增了FunctionalInterface,ArrayList中就使用了Predict, Consume, UnaryOperator等函数式编程接口。
modCount
在Iterator中定义了以下函数
final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
可以看出modCount主要是用来检查在迭代器操作List的过程中,List的结构是否发生了结构性的变化,防止多个对象共同操作一个List,会抛出异常。
package com.stephen.collection; import java.util.ArrayList; import java.util.Iterator; public class ArrayListTest { public static void main(String[] args) { ArrayList<String> al = new ArrayList<>(); al.add("one"); al.add("two"); al.add("three"); Iterator<String> iter = al.iterator(); while(iter.hasNext()) { System.out.println(iter.next()); al.add("four"); } } }
//output
Exception in thread “main” java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
at java.util.ArrayList$Itr.next(ArrayList.java:851)
at com.stephen.collection.ArrayListTest.main(ArrayListTest.java:16)
one
forEachRemaining()
在SubList和ArrayList中这个方法最后的cursor和lastRet的值不一样,Why?
Spliterator
Quite BIG ? – 有待继续学习
相关文章推荐
- 设计模式中类的关系
- 二进制中1的个数----位运算
- String、StringBuffer与StringBuilder之间区别
- 合唱队形
- 5.Python操作Redis:集合(Set)
- poj1015(dp输出路径)
- solrcloud分布式集群部署&zookeeper集群安装
- Java线程中 start与run的区别以及源码分析
- iOS -- MJExtension框架介绍
- HDU 1257 最少拦截系统(最长递减子序列的条数)
- python is 同一性运算符
- POJ 1021 Joseph
- poj2481 Cows (树状数组)
- 选择排序和冒泡排序
- Linux-24-linux基础重要命令01(L005-06)
- Spring IOC 深入分析
- 第一次课 圆面积
- Android 文件储存
- Hdu 4288 Coder(从小到大排列的集合中下标模5为3的数的和)
- 关于 MotionEvent 的笔记