ArrayList源码

1. package java.util;
3. import java.util.function.Consumer;
4. import java.util.function.Predicate;
5. import java.util.function.UnaryOperator;
7. /**
8. * 可以改变大小的List的实现，实现所有的List的操作，允许保存各种元素，包括null。除了实现
9. * List接口之外，这个类提供了操作内部存储数据的数组大小的方法。（这个类相当于Vector，
10. * 但是它并不是线程同步的，不是线程安全的）
11. *
12. * size,isEmpty,set,iterator,listIterator方法运行时间为常量时间，add方法运行为摊还常量
13. * 时间，也即增加n个元素的时间为O(n)。其他的操作运行时间大致为线性时间，常数因子相较
14. * 于LinkedList更小
15. *
16. * 每个ArrayList实例都有一个容量，是存储数据的数组的大小，他至少是List的元素数量的大小。
17. * 随着元素的增加，容量自动增加。容量增大的细节在添加一个元素有恒定的时间成本摊销的基础上
18. *
19. * 在添加大量元素前，应用程序可以使用ensureCapacity方法增大Arraylist的容量， 这可能减少
20. * 增量重新分配的次数
21. *
22. * 这个实现是非线程安全的，如果有多个线程同时操作一个ArrayList实例，其中至少有一个线程
23. * 在修改这个实例的结构，则必须在外部使用同步控制（一个结构上的修改操作指的是添加或删除一个
24. * 或多个元素，或者明确改变存储数据的数组大小，仅仅改变元素值不是结构上的修改），这一般由
25. * 封装ArrayList的类来进行。
26. *
27. * 如果没有这样的对象存在，列表应该使用Collections.synchronizedList方法来获得同步的
28. * （线程安全的）装饰对象（代理对象）。这个操作最好在创建的时候进行，来防止意外的非同步的
29. * 操作。还可以使用concurrent包下的CopyOnWriteArrayList代替ArrayList的使用
30. *
31. *
32. * 使用类的iterator（)和listIterator(int)方法会出发fail-fast错误机制（抛出
33. * ConcurrentModificationException异常），如果创建了iterator后进行结构上的修改，除了使
34. * 用iterator的remove或者add方法。因此，在并发修改时，iterator快速失败并且清除，而不是冒
35. * 着将来可能发生的不确定的风险。
36. *
37. * 迭代器的fail-fast错误机制不能被保证，通常来说，很难保证在非同步并发修改操作的fail-fast
38. * 机制。fail-fast错误机制的迭代器力所能及的抛出ConcurrentModificationException。
39. * 所以，开发时不应该依赖这个异常保证程序的正确性，仅仅在发现bug时使用
40. * 继承了AbstractList，可以继承部分默认的实现
41. * 实现了Cloneable, java.io.Serializable，允许克隆和序列化
42. */
44. publicclassArrayList<E>extendsAbstractList<E>
45. implementsList<E>,RandomAccess,Cloneable, java.io.Serializable
46. {
47. //序列号
48. privatestaticfinallong serialVersionUID =8683452581122892189L;
50. /**
51. * 列表默认容量
52. */
53. privatestaticfinalint DEFAULT_CAPACITY =10;
55. /**
56. * 共享空数组实例，用于空实例。调用构造函数容量为0时，会赋予数据的数组
57. */
58. privatestaticfinalObject[] EMPTY_ELEMENTDATA ={};
60. /**
61. * 共享空数组实例用于默认大小的空实例。使用默认构造函数时，会赋予数据的数组
62. */
63. privatestaticfinalObject[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA ={};
65. /**
66. * 存储数据的数组，数组大小就是列表的容量的大小。在第一次加入元素时，任何空实例
67. * （DEFAULTCAPACITY_EMPTY_ELEMENTDATA）会扩充成默认大小。
68. * transient表示序列化过程不希望被序列化的字段，ArrayList自己实现的序列化机制会
69. * 逐个序列化每个元素
70. */
71. transientObject[] elementData;// non-private to simplify nested class access
73. /**
74. * 列表中元素的数量
75. *
76. * @serial
77. */
78. privateint size;
80. /**
81. * 构造一个指定容量的空列表
82. *
83. * @param initialCapacity 列表的初始容量
84. * @throws IllegalArgumentException 传入的初始容量为负数时，抛出次异常
85. */
86. publicArrayList(int initialCapacity){
87. if(initialCapacity >0){
88. this.elementData =newObject[initialCapacity];
89. }elseif(initialCapacity ==0){
90. this.elementData = EMPTY_ELEMENTDATA;
91. }else{
92. thrownewIllegalArgumentException("Illegal Capacity: "+
93. initialCapacity);
94. }
95. }
97. /**
98. * 构造一个默认大小的空列表
99. */
100. publicArrayList(){
101. this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
102. }
104. /**
105. * 根据传入的集合，构造一个列表，元素的顺序是传入集合的迭代器返回的顺序
106. *
107. * @param c 传入的容器
108. * @throws NullPointerException 传入的容器为空时抛出异常
109. */
110. publicArrayList(Collection<?extends E> c){
111. elementData = c.toArray();
112. if((size = elementData.length)!=0){
113. // c.toArray()可能没有返回 Object[]
114. if(elementData.getClass()!=Object[].class)
115. //转成Object类型
116. elementData =Arrays.copyOf(elementData, size,Object[].class);
117. }else{
118. // 如果传入的集合没有元素，则使用空数组代替
119. this.elementData = EMPTY_ELEMENTDATA;
120. }
121. }
123. /**
124. * 减小列表的容器大小至列表中元素数量
125. */
126. publicvoid trimToSize(){
127. modCount++;
128. if(size < elementData.length){
129. elementData =(size ==0)
130. ? EMPTY_ELEMENTDATA
131. :Arrays.copyOf(elementData, size);
132. }
133. }
135. /**
136. * 增大ArrayList实例的容量, 如果必要，保证能够存储传入的最小容量个元素
137. *
138. * @param minCapacity 需要的最少的存储容量
139. */
140. publicvoid ensureCapacity(int minCapacity){
141. int minExpand =(elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
142. // any size if not default element table
143. ?0
144. // larger than default for default empty table. It's already
145. // supposed to be at default size.
146. : DEFAULT_CAPACITY;
148. if(minCapacity > minExpand){
149. ensureExplicitCapacity(minCapacity);
150. }
151. }
153. privatevoid ensureCapacityInternal(int minCapacity){
154. //默认大小数组，将数组扩展成默认或者minCapacity的大的容量
155. if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
156. minCapacity =Math.max(DEFAULT_CAPACITY, minCapacity);
157. }
159. ensureExplicitCapacity(minCapacity);
160. }
162. //确保数组能够保存足够的元素
163. privatevoid ensureExplicitCapacity(int minCapacity){
164. modCount++;
166. // 当要求的数量大于数组的大小，扩充成需要的数量
167. if(minCapacity - elementData.length >0)
168. grow(minCapacity);
169. }
171. /**
172. * 最大允许的容量
173. * 一些虚拟机会存储一些头信息
174. * 尝试分配大容量的数组会导致OutOfMemoryError，超出虚拟机的限制
175. */
176. privatestaticfinalint MAX_ARRAY_SIZE =Integer.MAX_VALUE -8;
178. /**
179. * 扩充容量以保证能够存储需要的容量（传入的参数）
180. *
181. * @param minCapacity 需要的容量大小
182. */
183. privatevoid grow(int minCapacity){
184. // overflow-conscious code
185. int oldCapacity = elementData.length;
186. //扩充原来容量的1/2，即扩大1.5倍
187. int newCapacity = oldCapacity +(oldCapacity >>1);
188. //如果需要的容量还是不够，则扩充至需要的容量的大小
189. if(newCapacity - minCapacity <0)
190. newCapacity = minCapacity;
191. /**
192. * 如果超出定义的最大容量，扩充至定义的最大容量（需要的容量小于等于定义的最大
193. * 容量）或最大int的值（需要的容量大小大于定义的最大容量）
194. * */
195. if(newCapacity - MAX_ARRAY_SIZE >0)
196. newCapacity = hugeCapacity(minCapacity);
197. // minCapacity is usually close to size, so this is a win:
198. elementData =Arrays.copyOf(elementData, newCapacity);
199. }
201. // 根据需要的容量大小，获得超大容量
202. privatestaticint hugeCapacity(int minCapacity){
203. if(minCapacity <0)// 如果minCapacity小于0，则超出最大整数值
204. thrownewOutOfMemoryError();
205. return(minCapacity > MAX_ARRAY_SIZE)?
206. Integer.MAX_VALUE :
207. MAX_ARRAY_SIZE;
208. }
210. /**
211. * 返回列表的中元素的数量
212. *
213. * @return 列表的中元素的数量
214. */
215. publicint size(){
216. return size;
217. }
219. /**
220. * 判断列表是否为空
221. *
222. * @return 当列表中没有元素则返回true，否则返回false
223. */
224. publicboolean isEmpty(){
225. return size ==0;
226. }
228. /**
229. * 当列表中存在传入的元素，返回true。进一步，列表中至少有一个传入的元素，则返回true
230. * 比如 o为null，则判断列表中是否有null元素，返回o与列表中的元素e的equals()比较的结果
231. *
232. * @param 需要检验是否在列表中的元素的对象
233. * @return 如果列表中存在o则返回true
234. */
235. publicboolean contains(Object o){
236. return indexOf(o)>=0;
237. }
239. /**
240. * 返回列表中第一次出现的o（equals方法返回true）的索引，如果不存在则返回-1
241. */
242. publicint indexOf(Object o){
243. if(o ==null){
244. for(int i =0; i < size; i++)
245. if(elementData[i]==null)
246. return i;
247. }else{
248. for(int i =0; i < size; i++)
249. if(o.equals(elementData[i]))
250. return i;
251. }
252. return-1;
253. }
255. /**
256. * 返回列表中最后一次出现的o（equals方法返回true）的索引，如果不存在则返回-1
257. */
258. publicint lastIndexOf(Object o){
259. if(o ==null){
260. for(int i = size-1; i >=0; i--)
261. if(elementData[i]==null)
262. return i;
263. }else{
264. for(int i = size-1; i >=0; i--)
265. if(o.equals(elementData[i]))
266. return i;
267. }
268. return-1;
269. }
271. /**
272. * 返回ArrayList实例的浅表复制，不复制列表的元素（都指向相同的对象，没有创建新的对
273. * 象）。
274. */
275. publicObject clone(){
276. try{
277. ArrayList<?> v =(ArrayList<?>)super.clone();
278. v.elementData =Arrays.copyOf(elementData, size);
279. v.modCount =0;
280. return v;
281. }catch(CloneNotSupportedException e){
282. // this shouldn't happen, since we are Cloneable
283. thrownewInternalError(e);
284. }
285. }
287. /**
288. * 获得按照列表顺序存储的数组，这个方法需要分配内存存储拷贝的数组。（浅复制）
289. *
290. * @return an array containing all of the elements in this list in
291. * proper sequence
292. */
293. publicObject[] toArray(){
294. returnArrays.copyOf(elementData, size);
295. }
297. /**
298. * 获得按照列表顺序存储的数组，返回一个泛型数组，这个方法需要分配内存存储拷贝的数组
299. * （浅复制），返回的数组的类型应该是参数指定的类型。如果传入的数组大小大于列表的元素
300. * 则返回，传入的数组，否则创建一个新的数组，并返回新创建的数组
301. *
302. * 如果传入的数组长度大于列表的长度，则设置其第size个元素为null（当且仅当在知道list中
303. * 没有null元素时，用于判断list中元素个数）
304. * @param a 如果足够大，存储列表中的元素，否则根据传入的运行时参数创建一个新的数组
305. * @return 返回列表元素的一个拷贝
306. * @throws ArrayStoreException if the runtime type of the specified array
307. * is not a supertype of the runtime type of every element in
308. * this list
309. * @throws NullPointerException if the specified array is null
310. */
311. @SuppressWarnings("unchecked")
312. public<T> T[] toArray(T[] a){
313. if(a.length < size)
314. // Make a new array of a's runtime type, but my contents:
315. return(T[])Arrays.copyOf(elementData, size, a.getClass());
316. System.arraycopy(elementData,0, a,0, size);
317. if(a.length > size)
318. a[size]=null;
319. return a;
320. }
322. /**
323. * 根据索引，获得列表中第index个元素，首先检查下标是否在正确的范围
324. */
325. @SuppressWarnings("unchecked")
326. E elementData(int index){
327. return(E) elementData[index];
328. }
330. /**
331. * 返回第index个元素
332. *
333. * @param index index of the element to return
334. * @return the element at the specified position in this list
335. * @throws IndexOutOfBoundsException {@inheritDoc}
336. */
337. public E get(int index){
338. rangeCheck(index);
340. return elementData(index);
341. }
343. /**
344. * 将第index个元素的值修改为传入的元素值，首先检查下标是否在正确的范围，返回修改前的值
345. *
346. * @param index 元素的索引
347. * @param element 设置到index的值
348. * @return 原来位于index的值
349. * @throws IndexOutOfBoundsException {@inheritDoc}
350. */
351. public E set(int index, E element){
352. rangeCheck(index);
354. E oldValue = elementData(index);
355. elementData[index]= element;
356. return oldValue;
357. }
359. /**
360. * 在列表的末尾添加元素，修改列表的元素数量（size）。首先需要确保列表的容量足够存放新
361. * 添加的元素。
362. *
363. * @param e element to be appended to this list
364. * @return <tt>true</tt> (as specified by {@link Collection#add})
365. */
366. publicboolean add(E e){
367. ensureCapacityInternal(size +1);// 确保能够存放添加元素，容量不足则扩容
368. elementData[size++]= e;
369. returntrue;
370. }
372. /**
373. * 在列表第index个位置插入一个元素，index及其后面的元素向后移动一个位置，然后将需要插
374. * 入的值存入第index的位置
375. *
376. * @param index index at which the specified element is to be inserted
377. * @param element element to be inserted
378. * @throws IndexOutOfBoundsException {@inheritDoc}
379. */
380. publicvoid add(int index, E element){
381. rangeCheckForAdd(index);
383. ensureCapacityInternal(size +1);// 确保有足够的存储空间
384. System.arraycopy(elementData, index, elementData, index +1,
385. size - index);
386. elementData[index]= element;
387. size++;
388. }
390. /**
391. * 移除列表中第index个元素，index后面的元素向前移动一个位置，列表元素数量减小1
392. *
393. * @param index 移除的元素的下标
394. * @return 返回被删除的元素
395. * @throws IndexOutOfBoundsException {@inheritDoc}
396. */
397. public E remove(int index){
398. rangeCheck(index);
400. modCount++;//
401. E oldValue = elementData(index);
403. int numMoved = size - index -1;
404. if(numMoved >0)
405. System.arraycopy(elementData, index+1, elementData, index,
406. numMoved);
407. elementData[--size]=null;// 释放，以让垃圾回收器回收
409. return oldValue;
410. }
412. /**
413. * 移除列表中第一个o（o为null时，第一个null元素，否则，是第一个equals()为true的元
414. * 素），如果过不存在，则不改变。如果列表中存在这样的元素，则返回true，否则返回false
415. *
416. * @param o element to be removed from this list, if present
417. * @return <tt>true</tt> if this list contained the specified element
418. */
419. publicboolean remove(Object o){
420. if(o ==null){
421. for(int index =0; index < size; index++)
422. if(elementData[index]==null){
423. fastRemove(index);
424. returntrue;
425. }
426. }else{
427. for(int index =0; index < size; index++)
428. if(o.equals(elementData[index])){
429. fastRemove(index);
430. returntrue;
431. }
432. }
433. returnfalse;
434. }
436. /*
437. * 快速移除元素，不检查索引范围，不返回被删除元素
438. */
439. privatevoid fastRemove(int index){
440. modCount++;
441. int numMoved = size - index -1;
442. if(numMoved >0)
443. System.arraycopy(elementData, index+1, elementData, index,
444. numMoved);
445. elementData[--size]=null;// 释放，以让垃圾回收器回收
446. }
448. /**
449. * 移除列表中所有的元素，操作后，列表为空
450. */
451. publicvoid clear(){
452. modCount++;
454. // 释放所有引用，以让垃圾收集器回收
455. for(int i =0; i < size; i++)
456. elementData[i]=null;
457. //列表大小改为0
458. size =0;
459. }
461. /**
462. * 向列表末尾添加c中的所有元素，顺序是c.iterator()返回的顺序，添加了元素返回true。
463. *
464. * @param c collection containing elements to be added to this list
465. * @return <tt>true</tt> if this list changed as a result of the call
466. * @throws NullPointerException if the specified collection is null
467. */
468. publicboolean addAll(Collection<?extends E> c){
469. Object[] a = c.toArray();
470. int numNew = a.length;
471. ensureCapacityInternal(size + numNew);// Increments modCount
472. System.arraycopy(a,0, elementData, size, numNew);
473. size += numNew;
474. return numNew !=0;
475. }
477. /**
478. * 向列表第index位置起添加c中的所有元素，顺序是c.iterator()返回的顺序，index及其后面
479. * 的元素向后移动c中元素个位置，添加了元素返回true。首先需要检查index是否是在范围内
480. *
481. * @param index index at which to insert the first element from the
482. * specified collection
483. * @param c collection containing elements to be added to this list
484. * @return <tt>true</tt> if this list changed as a result of the call
485. * @throws IndexOutOfBoundsException {@inheritDoc}
486. * @throws NullPointerException if the specified collection is null
487. */
488. publicboolean addAll(int index,Collection<?extends E> c){
489. rangeCheckForAdd(index);
491. Object[] a = c.toArray();
492. int numNew = a.length;
493. ensureCapacityInternal(size + numNew);// Increments modCount
495. int numMoved = size - index;
496. if(numMoved >0)
497. System.arraycopy(elementData, index, elementData, index + numNew,
498. numMoved);
500. System.arraycopy(a,0, elementData, index, numNew);
501. size += numNew;
502. return numNew !=0;
503. }
505. /**
506. * 移除元素，移除[fromIndex,toIndex)范围的元素，不包括toIndex
507. *
508. * @throws IndexOutOfBoundsException if {@code fromIndex} or
509. * {@code toIndex} is out of range
510. * ({@code fromIndex < 0 ||
511. * fromIndex >= size() ||
512. * toIndex > size() ||
513. * toIndex < fromIndex})
514. */
515. protectedvoid removeRange(int fromIndex,int toIndex){
516. modCount++;
517. int numMoved = size - toIndex;
518. System.arraycopy(elementData, toIndex, elementData, fromIndex,
519. numMoved);
521. // 释放（移动后列表最后一个元素之后的）引用，以让垃圾收集器回收
522. int newSize = size -(toIndex-fromIndex);
523. for(int i = newSize; i < size; i++){
524. elementData[i]=null;
525. }
526. size = newSize;
527. }
529. /**
530. * 检查索引值是否在合理的范围内，不在则抛出异常
531. * negative: It is always used immediately prior to an array access,
532. * which throws an ArrayIndexOutOfBoundsException if index is negative.
533. */
534. privatevoid rangeCheck(int index){
535. if(index >= size)
536. thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
537. }
539. /**
540. * 检查索引值是否在合理的范围内，不在则抛出异常
541. */
542. privatevoid rangeCheckForAdd(int index){
543. if(index > size || index <0)
544. thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
545. }
547. /**
548. * 生成数组越界异常信息
549. */
550. privateString outOfBoundsMsg(int index){
551. return"Index: "+index+", Size: "+size;
552. }
554. /**
555. * 移除列表中的c中包含的所有元素
556. *
557. * @param c 需要移除的元素集合，不能为空
558. * @return 如果列表改变了，则返回true，否则返回false
559. * @throws ClassCastException 如果传入的集合中有与列表中元素类型不匹配时，抛出该异
560. * 常
561. * @throws NullPointerException ArrayList不支持null，但c中包含null元素时，抛出该
562. * 异常
563. */
564. publicboolean removeAll(Collection<?> c){
565. Objects.requireNonNull(c);
566. return batchRemove(c,false);
567. }
569. /**
570. * 保留列表中与c中共有的元素（求交集）。
571. *
572. * @param c 需要完成交集的集合，不允许为空
573. * @return 如果列表改变了，则返回true，否则返回false
574. * @throws ClassCastException 如果传入的集合中有与列表中元素类型不匹配时，抛出该异
575. * 常
576. * @throws NullPointerException ArrayList不支持null，但c中包含null元素时，抛出该
577. * 异常
578. */
579. publicboolean retainAll(Collection<?> c){
580. Objects.requireNonNull(c);
581. return batchRemove(c,true);
582. }
584. /**
585. * 批量删除, complement为true时，保留与c中相同的元素，否则，保留与c中不相同的元素
586. */
587. privateboolean batchRemove(Collection<?> c,boolean complement){
588. finalObject[] elementData =this.elementData;
589. int r =0, w =0;
590. boolean modified =false;
591. try{
592. for(; r < size; r++)
593. if(c.contains(elementData[r])== complement)
594. elementData[w++]= elementData[r];
595. }finally{
596. //保护动作，当c.contains()抛出异常时，将剩余的（r之后的）元素保留
597. if(r != size){
598. System.arraycopy(elementData, r,
599. elementData, w,
600. size - r);
601. w += size - r;
602. }
603. if(w != size){
604. // 有元素需要被移除时，释放引用，以让垃圾回收器回收
605. for(int i = w; i < size; i++)
606. elementData[i]=null;
607. modCount += size - w;
608. size = w;
609. modified =true;
610. }
611. }
612. return modified;
613. }
615. /**
616. * 将一个ArrayList实例的状态保存到流中，也即序列化，这是类实现的序列化机制，不是默认
617. * 的序列化机制
618. *
619. * @serialData The length of the array backing the <tt>ArrayList</tt>
620. * instance is emitted (int), followed by all of its elements
621. * (each an <tt>Object</tt>) in the proper order.
622. */
623. privatevoid writeObject(java.io.ObjectOutputStream s)
624. throws java.io.IOException{
625. // Write out element count, and any hidden stuff
626. int expectedModCount = modCount;
627. s.defaultWriteObject();//默认序列化，记录列表中元素的个数
629. // 将列表大小作为容量保存，以此适用于clone()
630. s.writeInt(size);
632. // 按照正确顺序保存列表中的元素
633. for(int i=0; i<size; i++){
634. s.writeObject(elementData[i]);
635. }
636. //序列化过程中是否有修改列表的结构（扩容，添加，移除操作）
637. //如果有，则抛出ConcurrentModificationException异常
638. if(modCount != expectedModCount){
639. thrownewConcurrentModificationException();
640. }
641. }
643. /**
644. * 从流中读取并重新创建Arraylist，也即反序列化
645. */
646. privatevoid readObject(java.io.ObjectInputStream s)
647. throws java.io.IOException,ClassNotFoundException{
648. elementData = EMPTY_ELEMENTDATA;
650. // Read in size, and any hidden stuff
651. s.defaultReadObject();//默认反序列化，读取列表元素个数
653. // 读取容量，忽略
654. s.readInt();// ignored
656. if(size >0){
657. // 类似于clone()，创建大小与元素个数相同的数组
658. ensureCapacityInternal(size);
660. Object[] a = elementData;
661. // 以正确的顺序读取所有的元素
662. for(int i=0; i<size; i++){
663. a[i]= s.readObject();
664. }
665. }
666. }
668. /**
669. * 创建一个从index开始的ListIterator（第一次调用next，返回index处的元素），调用
670. * previous，则返回index-1处的元素，首先检查index的正确性
671. *
672. * The returned list iterator is fail-fast
673. *
674. * @throws IndexOutOfBoundsException {@inheritDoc}
675. */
676. publicListIterator<E> listIterator(int index){
677. if(index <0|| index > size)
678. thrownewIndexOutOfBoundsException("Index: "+index);
679. returnnewListItr(index);
680. }
682. /**
683. * 重载，创建一个默认从0开始的ListIterator
684. *
685. * The returned list iterator is fail-fast
686. *
687. * @see #listIterator(int)
688. */
689. publicListIterator<E> listIterator(){
690. returnnewListItr(0);
691. }
693. /**
694. * 按照正确的顺序，产生一个iterator
695. *
696. * @return an iterator over the elements in this list in proper sequence
697. */
698. publicIterator<E> iterator(){
699. returnnewItr();
700. }
702. /**
703. * AbstractList.Itr的优化
704. */
705. privateclassItrimplementsIterator<E>{
706. int cursor;// 下一个元素的游标（索引）
707. int lastRet =-1;// 上一次返回的元素的索引
708. int expectedModCount = modCount;
709. //是否存在下一个，没有遍历到末尾，返回true
710. publicboolean hasNext(){
711. return cursor != size;
712. }
714. //返回下一个元素
715. @SuppressWarnings("unchecked")
716. public E next(){
717. //检查迭代器过程中，是否有修改ArrayList的实例的结构
718. //有则抛出ConcurrentModificationException异常
719. checkForComodification();
720. int i = cursor;
721. if(i >= size)
722. thrownewNoSuchElementException();//超出size范围，则抛出异常
723. Object[] elementData =ArrayList.this.elementData;
724. if(i >= elementData.length)
725. thrownewConcurrentModificationException();
726. cursor = i +1;//记录下一个元素的游标值
727. return(E) elementData[lastRet = i];
728. }
729. //移除当前的元素（next()获得的元素，cursor已经指向下一个）
730. publicvoid remove(){
731. //上一个元素不存在
732. if(lastRet <0)
733. thrownewIllegalStateException();
734. checkForComodification();//检查是否修改
736. try{
737. ArrayList.this.remove(lastRet);//移除lastRet处的元素
738. cursor = lastRet;
739. lastRet =-1;
740. expectedModCount = modCount;
741. }catch(IndexOutOfBoundsException ex){
742. thrownewConcurrentModificationException();
743. }
744. }
746. /**
747. * 对剩余未迭代的元素进行指定操作，直到所有的元素都已经被处理或行动将抛出一个异常
748. */
749. @Override
750. @SuppressWarnings("unchecked")
751. publicvoid forEachRemaining(Consumer<?super E> consumer){
752. Objects.requireNonNull(consumer);
753. finalint size =ArrayList.this.size;
754. int i = cursor;
755. //已经遍历完成，不需要继续遍历
756. if(i >= size){
757. return;
758. }
759. finalObject[] elementData =ArrayList.this.elementData;
760. if(i >= elementData.length){
761. thrownewConcurrentModificationException();
762. }
763. while(i != size && modCount == expectedModCount){
764. consumer.accept((E) elementData[i++]);
765. }
766. // 更新游标和上一次返回的元素，并检测是否修改了列表结构
767. cursor = i;
768. lastRet = i -1;
769. checkForComodification();
770. }
772. finalvoid checkForComodification(){
773. if(modCount != expectedModCount)
774. thrownewConcurrentModificationException();
775. }
776. }
778. /**
779. * AbstractList.ListItr的优化，继承自Iter
780. */
781. privateclassListItrextendsItrimplementsListIterator<E>{
782. ListItr(int index){
783. super();
784. cursor = index;//指定第一个需要返回的元素为index
785. }
787. //返回是否有前一个元素，直到到列表的第0个元素
788. publicboolean hasPrevious(){
789. return cursor !=0;
790. }
791. //返回下一个元素的游标
792. publicint nextIndex(){
793. return cursor;
794. }
795. //返回上一个元素的游标
796. publicint previousIndex(){
797. return cursor -1;
798. }
800. //获取上一个元素
801. @SuppressWarnings("unchecked")
802. public E previous(){
803. checkForComodification();//检查是否修改了列表的结构
804. int i = cursor -1;//获得上一个元素索引
805. //数组越界则抛出异常
806. if(i <0)
807. thrownewNoSuchElementException();
808. Object[] elementData =ArrayList.this.elementData;
809. if(i >= elementData.length)
810. thrownewConcurrentModificationException();
811. cursor = i;//修改游标，下一个元素还是当前返回的previous元素
812. return(E) elementData[lastRet = i];
813. }
815. //设置当前元素（lastRet指向的值）的值为e
816. publicvoidset(E e){
817. if(lastRet <0)
818. thrownewIllegalStateException();
819. checkForComodification();
821. try{
822. ArrayList.this.set(lastRet, e);
823. }catch(IndexOutOfBoundsException ex){
824. thrownewConcurrentModificationException();
825. }
826. }
827. //在下一个游标处添加一个元素（remove的时候，游标回到移除的元素位置）
828. publicvoid add(E e){
829. checkForComodification();
831. try{
832. int i = cursor;
833. ArrayList.this.add(i, e);
834. cursor = i +1;
835. lastRet =-1;
836. expectedModCount = modCount;
837. }catch(IndexOutOfBoundsException ex){
838. thrownewConcurrentModificationException();
839. }
840. }
841. }
843. /**
844. * 返回一个子列表，子列表的范围为列表[fromIndex,toIndex)之间的元素，不包括同Index
845. * 如果fromIndex和同Index相同，则返回空列表
846. * 不创建新的List，在SubList中持有一个当前ArrayList实例的引用，以及子列表的索引范围
847. * 子列表的语义将变得不明确如果当前ArrayList实例结构发生变化（增删、扩容）
848. * @throws IndexOutOfBoundsException {@inheritDoc}
849. * @throws IllegalArgumentException {@inheritDoc}
850. */
851. publicList<E> subList(int fromIndex,int toIndex){
852. subListRangeCheck(fromIndex, toIndex, size);
853. returnnewSubList(this,0, fromIndex, toIndex);
854. }
856. //检查子列表范围是否正确
857. staticvoid subListRangeCheck(int fromIndex,int toIndex,int size){
858. if(fromIndex <0)
859. thrownewIndexOutOfBoundsException("fromIndex = "+ fromIndex);
860. if(toIndex > size)
861. thrownewIndexOutOfBoundsException("toIndex = "+ toIndex);
862. if(fromIndex > toIndex)
863. thrownewIllegalArgumentException("fromIndex("+ fromIndex +
864. ") > toIndex("+ toIndex +")");
865. }
866. /*Sublist-Start*/
867. //定义子列表类，维持一个获得子列表的ArrayList实例以及偏移量
868. //子列表偏移量和列表大小
869. privateclassSubListextendsAbstractList<E>implementsRandomAccess{
870. privatefinalAbstractList<E> parent;
871. privatefinalint parentOffset;
872. privatefinalint offset;
873. int size;
874. //构造方法，传入父列表，子列表偏移量，开始的索引和结束的索引
875. SubList(AbstractList<E> parent,
876. int offset,int fromIndex,int toIndex){
877. this.parent = parent;
878. this.parentOffset = fromIndex;
879. this.offset = offset + fromIndex;
880. this.size = toIndex - fromIndex;
881. this.modCount =ArrayList.this.modCount;
882. }
883. //设置index处的值为e，直接操作父列表，需要检查范围
884. public E set(int index, E e){
885. rangeCheck(index);
886. checkForComodification();
887. E oldValue =ArrayList.this.elementData(offset + index);
888. ArrayList.this.elementData[offset + index]= e;
889. return oldValue;
890. }
891. //获取index处的值，需要检查范围，并检查是否有修改
892. public E get(int index){
893. rangeCheck(index);
894. checkForComodification();
895. returnArrayList.this.elementData(offset + index);
896. }
897. //获得子列表的大小，检查是否有修改
898. publicint size(){
899. checkForComodification();
900. returnthis.size;
901. }
902. //在index处添加一个元素e，需要检查范围和是否有修改
903. publicvoid add(int index, E e){
904. rangeCheckForAdd(index);
905. checkForComodification();
906. parent.add(parentOffset + index, e);
907. this.modCount = parent.modCount;
908. this.size++;
909. }
910. //移除index处的元素，并返回删除的元素
911. public E remove(int index){
912. rangeCheck(index);
913. checkForComodification();
914. E result = parent.remove(parentOffset + index);
915. this.modCount = parent.modCount;
916. this.size--;
917. return result;
918. }
919. //移除[fromIndex,toIndex)之间的元素，检查是否有修改列表结构
920. protectedvoid removeRange(int fromIndex,int toIndex){
921. checkForComodification();
922. parent.removeRange(parentOffset + fromIndex,
923. parentOffset + toIndex);
924. this.modCount = parent.modCount;
925. this.size -= toIndex - fromIndex;
926. }
927. //在子列表末尾添加c中所有元素
928. publicboolean addAll(Collection<?extends E> c){
929. return addAll(this.size, c);
930. }
932. //在子列表index起添加c中所有元素，需要检查范围和是否有修改
933. publicboolean addAll(int index,Collection<?extends E> c){
934. rangeCheckForAdd(index);
935. int cSize = c.size();
936. if(cSize==0)
937. returnfalse;
939. checkForComodification();
940. parent.addAll(parentOffset + index, c);
941. this.modCount = parent.modCount;
942. this.size += cSize;
943. returntrue;
944. }
945. //获得迭代器
946. publicIterator<E> iterator(){
947. return listIterator();
948. }
949. //获得ListIterator迭代器（可向前、向后）
950. publicListIterator<E> listIterator(finalint index){
951. checkForComodification();
952. rangeCheckForAdd(index);
953. finalint offset =this.offset;
955. returnnewListIterator<E>(){
956. int cursor = index;
957. int lastRet =-1;
958. int expectedModCount =ArrayList.this.modCount;
960. publicboolean hasNext(){
961. return cursor !=SubList.this.size;
962. }
964. @SuppressWarnings("unchecked")
965. public E next(){
966. checkForComodification();
967. int i = cursor;
968. if(i >=SubList.this.size)
969. thrownewNoSuchElementException();
970. Object[] elementData =ArrayList.this.elementData;
971. if(offset + i >= elementData.length)
972. thrownewConcurrentModificationException();
973. cursor = i +1;
974. return(E) elementData[offset +(lastRet = i)];
975. }
977. publicboolean hasPrevious(){
978. return cursor !=0;
979. }
981. @SuppressWarnings("unchecked")
982. public E previous(){
983. checkForComodification();
984. int i = cursor -1;
985. if(i <0)
986. thrownewNoSuchElementException();
987. Object[] elementData =ArrayList.this.elementData;
988. if(offset + i >= elementData.length)
989. thrownewConcurrentModificationException();
990. cursor = i;
991. return(E) elementData[offset +(lastRet = i)];
992. }
993. //对未迭代的元素进行特定的操作，并将游标移到迭代完成的位置
994. @SuppressWarnings("unchecked")
995. publicvoid forEachRemaining(Consumer<?super E> consumer){
996. Objects.requireNonNull(consumer);
997. finalint size =SubList.this.size;
998. int i = cursor;
999. if(i >= size){
1000. return;
1001. }
1002. finalObject[] elementData =ArrayList.this.elementData;
1003. if(offset + i >= elementData.length){
1004. thrownewConcurrentModificationException();
1005. }
1006. while(i != size && modCount == expectedModCount){
1007. consumer.accept((E) elementData[offset +(i++)]);
1008. }
1009. //更新游标
1010. lastRet = cursor = i;
1011. checkForComodification();
1012. }
1014. publicint nextIndex(){
1015. return cursor;
1016. }
1018. publicint previousIndex(){
1019. return cursor -1;
1020. }
1022. publicvoid remove(){
1023. if(lastRet <0)
1024. thrownewIllegalStateException();
1025. checkForComodification();
1027. try{
1028. SubList.this.remove(lastRet);
1029. cursor = lastRet;
1030. lastRet =-1;
1031. expectedModCount =ArrayList.this.modCount;
1032. }catch(IndexOutOfBoundsException ex){
1033. thrownewConcurrentModificationException();
1034. }
1035. }
1037. publicvoidset(E e){
1038. if(lastRet <0)
1039. thrownewIllegalStateException();
1040. checkForComodification();
1042. try{
1043. ArrayList.this.set(offset + lastRet, e);
1044. }catch(IndexOutOfBoundsException ex){
1045. thrownewConcurrentModificationException();
1046. }
1047. }
1049. publicvoid add(E e){
1050. checkForComodification();
1052. try{
1053. int i = cursor;
1054. SubList.this.add(i, e);
1055. cursor = i +1;
1056. lastRet =-1;
1057. expectedModCount =ArrayList.this.modCount;
1058. }catch(IndexOutOfBoundsException ex){
1059. thrownewConcurrentModificationException();
1060. }
1061. }
1063. finalvoid checkForComodification(){
1064. if(expectedModCount !=ArrayList.this.modCount)
1065. thrownewConcurrentModificationException();
1066. }
1067. };
1068. }
1069. //从当前子序列获得子序列，offset当前子列表位于最原始的列表的偏移
1070. publicList<E> subList(int fromIndex,int toIndex){
1071. subListRangeCheck(fromIndex, toIndex, size);
1072. returnnewSubList(this, offset, fromIndex, toIndex);
1073. }
1074. //检查当前索引的范围是否正确
1075. privatevoid rangeCheck(int index){
1076. if(index <0|| index >=this.size)
1077. thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
1078. }
1079. //检查当前索引的范围是否正确
1080. privatevoid rangeCheckForAdd(int index){
1081. if(index <0|| index >this.size)
1082. thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
1083. }
1084. //生成索引越界错误消息
1085. privateString outOfBoundsMsg(int index){
1086. return"Index: "+index+", Size: "+this.size;
1087. }
1088. //判断是否有修改
1089. privatevoid checkForComodification(){
1090. if(ArrayList.this.modCount !=this.modCount)
1091. thrownewConcurrentModificationException();
1092. }
1094. publicSpliterator<E> spliterator(){
1095. checkForComodification();
1096. //子列表的已经不是第一次使用
1097. //fence 为父列表中属于子列表的最后一个元素的索引
1098. returnnewArrayListSpliterator<E>(ArrayList.this, offset,
1099. offset +this.size,this.modCount);
1100. }
1101. }
1103. /**
1104. * 对数组中的元素执行特定的操作，不允许在此过程中修改
1105. */
1106. @Override
1107. publicvoid forEach(Consumer<?super E> action){
1108. Objects.requireNonNull(action);
1109. finalint expectedModCount = modCount;
1110. @SuppressWarnings("unchecked")
1111. final E[] elementData =(E[])this.elementData;
1112. finalint size =this.size;
1113. for(int i=0; modCount == expectedModCount && i < size; i++){
1114. action.accept(elementData[i]);
1115. }
1116. if(modCount != expectedModCount){
1117. thrownewConcurrentModificationException();
1118. }
1119. }
1121. /**
1122. * 在列表上创建一个延迟绑定和fail-fast机制
1123. *
1124. * Spliterator提供列表的遍历和元素分割
1125. *
1126. * @return a {@code Spliterator} over the elements in this list
1127. * @since 1.8
1128. */
1129. @Override
1130. publicSpliterator<E> spliterator(){
1131. returnnewArrayListSpliterator<>(this,0,-1,0);
1132. }
1134. /** Index-based split-by-two, lazily initialized Spliterator */
1135. staticfinalclassArrayListSpliterator<E>implementsSpliterator<E>{
1137. /*
1138. * 实在看不懂 ==！
1139. * 如果ArrayList是不可变或者结构上不可变的（adds，removs等），可以使用
1140. * Arrays.spliterator来实现。遍历过程中，不牺牲太多性能的情况下，我们可以检测到
1141. * 干扰。（不太通，Instead we detect as much interference during traversal
1142. * as practical without sacrificing much performance.） 我们主要依赖于
1143. * modCounts。虽然这并不能保证检查到并发访问冲突，而且有时对于线程间的干扰过于保
1144. * 守，但是发现足够的问题在实践中是值得的。为了实现这个功能，做了以下几点：
1145. * 1. 延迟初始化fence和expectedModCount直到需要我们提交我们正在检测的状态信息
1146. * 以此提高精确性(这不适用于子列表，子列表使用非延迟加载值）
1147. * 2. 只在forEach结束时检测一次ConcurrentModificationException异常（性能最
1148. * 敏感的方法）。使用forEach（与迭代器相反），我们通常只能在action操作之后检测
1149. * 干扰，而不是开始之前。因为干扰的原因，假设如null或者列表元素很小，更进一步的
1150. * CME-triggering检测将应用于所有的可能破外。这允许forEach内部的循环在运行时不
1151. * 进行进一步检查，简化lambda表达式的操作。虽然这确实需要大量的检查（
1152. * list.stream().forEach(a)相同的情况）, 没有其他的检测和计算发生在forEach内，
1153. * 其他不常使用的方法不能从流中获得大部分性能
1154. */
1156. privatefinalArrayList<E> list;
1157. privateint index;// 当前的索引（advance/split操作的对象）
1158. privateint fence;// -1 until used; then one past last index
1159. privateint expectedModCount;// 当fence设置后初始化
1161. /** 根据范围创建一个Spliterator */
1162. ArrayListSpliterator(ArrayList<E> list,int origin,int fence,
1163. int expectedModCount){
1164. this.list = list;// 可以是null（除非需要遍历）
1165. this.index = origin;
1166. this.fence = fence;
1167. this.expectedModCount = expectedModCount;
1168. }
1170. privateint getFence(){// 第一次使用时，初始化fence为size
1171. int hi;// (a specialized variant appears in method forEach)
1172. ArrayList<E> lst;
1173. if((hi = fence)<0){//第一次使用，则初始化
1174. if((lst = list)==null)
1175. hi = fence =0;
1176. else{
1177. expectedModCount = lst.modCount;//初始化expectedModCount
1178. hi = fence = lst.size;
1179. }
1180. }
1181. return hi;
1182. }
1184. publicArrayListSpliterator<E> trySplit(){
1185. //求中间索引，>>>无符号右移，高位补0
1186. int hi = getFence(), lo = index, mid =(lo + hi)>>>1;
1187. return(lo >= mid)?null:// 分成两份，如果列表太小返回null
1188. newArrayListSpliterator<E>(list, lo, index = mid,
1189. expectedModCount);
1190. }
1192. //执行特定操作，用于遍历，每调用一次，index增大，知道fence（也即到列表末尾）
1193. publicboolean tryAdvance(Consumer<?super E> action){
1194. if(action ==null)
1195. thrownewNullPointerException();
1196. int hi = getFence(), i = index;
1197. if(i < hi){
1198. index = i +1;
1199. @SuppressWarnings("unchecked") E e =(E)list.elementData[i];
1200. action.accept(e);
1201. if(list.modCount != expectedModCount)
1202. thrownewConcurrentModificationException();
1203. returntrue;
1204. }
1205. returnfalse;
1206. }
1208. //遍历执行特定操作
1209. publicvoid forEachRemaining(Consumer<?super E> action){
1210. int i, hi, mc;// hoist accesses and checks from loop
1211. ArrayList<E> lst;Object[] a;
1212. if(action ==null)
1213. thrownewNullPointerException();
1214. if((lst = list)!=null&&(a = lst.elementData)!=null){
1215. if((hi = fence)<0){
1216. mc = lst.modCount;
1217. hi = lst.size;
1218. }
1219. else
1220. mc = expectedModCount;
1221. if((i = index)>=0&&(index = hi)<= a.length){
1222. for(; i < hi;++i){
1223. @SuppressWarnings("unchecked") E e =(E) a[i];
1224. action.accept(e);
1225. }
1226. if(lst.modCount == mc)
1227. return;
1228. }
1229. }
1230. thrownewConcurrentModificationException();
1231. }
1232. //获得还剩余的未遍历的元素数
1233. publiclong estimateSize(){
1234. return(long)(getFence()- index);
1235. }
1237. //Spliterator特征
1238. publicint characteristics(){
1239. returnSpliterator.ORDERED |Spliterator.SIZED |Spliterator.SUBSIZED;
1240. }
1241. }
1243. /**
1244. * 根据条件移除元素，元素有移除，则返回true
1245. */
1246. @Override
1247. publicboolean removeIf(Predicate<?super E> filter){
1248. Objects.requireNonNull(filter);
1249. // figure out which elements are to be removed
1250. // any exception thrown from the filter predicate at this stage
1251. // will leave the collection unmodified
1252. int removeCount =0;
1253. finalBitSet removeSet =newBitSet(size);
1254. finalint expectedModCount = modCount;
1255. finalint size =this.size;
1256. for(int i=0; modCount == expectedModCount && i < size; i++){
1257. @SuppressWarnings("unchecked")
1258. final E element =(E) elementData[i];
1259. if(filter.test(element)){
1260. removeSet.set(i);//设置第i位为1，标记移除
1261. removeCount++;//记录移除的记录数
1262. }
1263. }
1264. //此过程中发生列表结构修改，抛出异常
1265. if(modCount != expectedModCount){
1266. thrownewConcurrentModificationException();
1267. }
1269. // 将没有移除的元素向前移动
1270. finalboolean anyToRemove = removeCount >0;
1271. if(anyToRemove){
1272. finalint newSize = size - removeCount;
1273. for(int i=0, j=0;(i < size)&&(j < newSize); i++, j++){
1274. //找到i之后第一个为false的index，也即未标记移除的
1275. i = removeSet.nextClearBit(i);
1276. elementData[j]= elementData[i];
1277. }
1278. for(int k=newSize; k < size; k++){
1279. elementData[k]=null;//清除需要删除的引用，以让垃圾回收器回收
1280. }
1281. this.size = newSize;//更新尺寸
1282. //此过程中发生列表结构修改，抛出异常
1283. if(modCount != expectedModCount){
1284. thrownewConcurrentModificationException();
1285. }
1286. modCount++;
1287. }
1288. //移除元素，则返回true
1289. return anyToRemove;
1290. }
1292. /**
1293. * 对列表中每一个元素根据传入的UnaryOperator，执行特定操作，并用返回值替换原来的值
1294. */
1295. @Override
1296. @SuppressWarnings("unchecked")
1297. publicvoid replaceAll(UnaryOperator<E>operator){
1298. Objects.requireNonNull(operator);
1299. finalint expectedModCount = modCount;
1300. finalint size =this.size;
1301. for(int i=0; modCount == expectedModCount && i < size; i++){
1302. //执行特定操作，并用返回值替换原来的值
1303. elementData[i]=operator.apply((E) elementData[i]);
1304. }
1305. if(modCount != expectedModCount){
1306. thrownewConcurrentModificationException();
1307. }
1308. modCount++;
1309. }
1311. //根据传入的比较器c对列表进行排序
1312. @Override
1313. @SuppressWarnings("unchecked")
1314. publicvoid sort(Comparator<?super E> c){
1315. finalint expectedModCount = modCount;
1316. Arrays.sort((E[]) elementData,0, size, c);
1317. //排序过程中发生列表结构变化，则抛出异常
1318. if(modCount != expectedModCount){
1319. thrownewConcurrentModificationException();
1320. }
1321. modCount++;
1322. }
1323. }

ArrayList 中的很大部分操作，使用了Arrays.copyof()和System.arraycopy()进行数组的拷贝，需要进一步分析其源码
列表的排序使用Arrays.sort()，进一步分析其源码

来自为知笔记(Wiz)