JDK源码阅读-------自学笔记(二十一)(java.util.ArrayList详细版集合类)

一、前景提要

本人经历了IT行业的多种类型企业,外包/创业小公司/中型公司,一步步成长起来,现在可以给大家透露下为什么进大企业在IT行业是重要的:

• 在外包公司,你要做的就是对接别人写好的接口,然后按照其要求编写一个业务的接口或者几个接口,那么你的技术也就是会写接口,而且还不是全面的,因为只会让你做那部分接口,而不是项目的全部,你对于数据库如何链接,数据库类型,数据库业务逻辑的操作都不会很清楚,所以你做的工作就是跟前段或者没有前段的做单独业务的对接,很多部分都是别人写好的,但是你又看不到,所以你根本不清楚整个业务逻辑是什么.
• 创业公司小公司(50-500),由于人员少,企业的资金有限,所以很多时候你需要一个人兼职多项工作,多项工作,作为后端就需要会运维服务(Linux),项目部署,系统架构的基本架构搭建,后端的数据库连接,数据库设计,数据库建表,SQL语句的书写,后端三层架构的数据传递等等技能,这里需要的是一种多功能工,虽然你可以会很多技能,但是你也没有一项是精通的技能,所以你也只是一个能干活的员工而已,距离成为架构师,技术总监没有发展起来的可能性,除非你的企业三五年内能增长到几千,上万的员工,但是,按照我国的情况,几乎是不可能的.
• 中型企业(1000-5000),这时候的项目就已经有了一些架构的雏形,否则的话项目越写越大,越写越冗余,总会写到崩溃的,而这时候很多的设计模式,就会应用到框架当中,代码的抽象,分布式设计,也会在代码中体现出来,架构上也会分出应用层和中台服务架构,会有一些设计的灵活且便于扩展的代码.

二、学习方案

• 由于上述原因,所以开始决定学习源码,但是源码并不是那么好学,很多需要反复查看,反复推敲,才能理解源码的含义,主要经历一下三步来阅读源码:
• 1.对接源码接口,仿写已有的代码设计,加上自己理解的标注,运行通畅,知晓源码的写法
• 2.改写实现的接口和父类,知晓一个方法是怎么实现,然后再拓展查看其他的方法是如何实现的
• 3.自定义源码的接口写法,以便可以独立开发出接口相同的方法,也是对算法理解的实现
• 在源码阅读上,本人的一个想法就是当作古诗词学习,古诗词众所周知是讲的经典的词汇和语言,而在编程当中,源码就相当于古诗词在汉语中的地位,所以学习和记忆源码,就相当于学习记忆古诗词一样,而仿写就相当于为古诗词做注,就是加上自己的解释和说明,便于理解和记忆.

三、常用集合类

1、ArrayList简述

• (1) ArrayList基于List实现的,数组长度是有限的,但是,ArrayList是可以存放人任意数量的对象,长度不受限制
• (2),底层是数组,通过属性Object数组可知,实现了可以再分配的功能,当添加元素的时候,会自动增加,即扩容机制
• (3)是线程不安全的,查找速度快,增删改速度慢

2、ArrayList和Collection的关系:

3、ArrayList数据结构:

• (1)底层结构是数组, Object类型, 源码

    // 默认空数组的初始化
    private static final Object[] EMPTY_ELEMENT_DATA = {};

• (2)因为是Object类型和使用了泛化,所以可以存储所有类型.默认数组长度是10

4、ArrayList继承关系:

二、核心方法

1、add()方法仿写

(1)ArrayList仿写(其中一些命名与现在的代码规范不符合,所以改写成了现在的规范)

  1 package com.synway.test.collections.version001.addmethod.impl;
  2     import java.util.*;
  3     /**
  4     * 仿写List
  5     *
  6     * @author liuyangos8888
  7     */
  8     public class MyArrayList<E> extends AbstractList<E>
  9         implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
 10
 11     /**
 12      * 默认的数组大小,数组默认大小是10
 13      */
 14     private static final int DEFAULT_CAPACITY = 10;
 15
 16
 17     /**
 18      * 默认空数组的初始化
 19      */
 20     private static final Object[] EMPTY_ELEMENT_DATA = {};
 21
 22
 23     /**
 24      * 默认共享数组空间,用于区分添加第一个元素空间扩容多少
 25      */
 26     private static final Object[] DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA = {};
 27
 28
 29     /**
 30      * 存储ArrayList元素的数组缓冲区。
 31      * ArrayList的容量是此数组缓冲区的长度.
 32      * 添加第一个元素时，任何具有elementData == DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA的
 33      * 空ArrayList都将扩展为DEFAULT_CAPACITY。
 34      * <p>
 35      * <p>
 36      * 缓冲区数组,任何被赋值的数组都会变为容量为默认10的数组
 37      */
 38     transient Object[] elementData;
 39
 40
 41     /**
 42      * 包含元素的数组的大小
 43      */
 44     private int size;
 45
 46
 47     /**
 48      * 要分配的最大数组大小。
 49      * 一些虚拟机在数组中保留一些标题字。
 50      * 尝试分配更大的阵列可能会导致*
 51      * OutOfMemoryError：请求的阵列大小超出VM限制
 52      */
 53     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 54
 55
 56     /**
 57      * 构造一个初始容量为10的空数组
 58      */
 59     public MyArrayList() {
 60
 61         this.elementData = DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA;
 62     }
 63
 64
 65     /**
 66      * 构造一个具有指定初始容量的空数组
 67      *
 68      * @param initialCapacity 列表的初始容量
 69      * @throws IllegalArgumentException 如果指定的初始容量为负数时
 70      */
 71     public MyArrayList(int initialCapacity) {
 72
 73         // 输入容量大于零
 74         if (initialCapacity > 0) {
 75
 76             this.elementData = new Object[initialCapacity];
 77
 78             // 输入容量等于零
 79         } else if (initialCapacity == 0) {
 80
 81             this.elementData = EMPTY_ELEMENT_DATA;
 82
 83             // 输入容量小于零
 84         } else {
 85             throw new IllegalArgumentException("Illegal Capacity: " +
 86                     initialCapacity);
 87         }
 88     }
 89
 90
 91     /**
 92      * 添加元素
 93      * 将指定的元素追加到此数组的末尾
 94      *
 95      * @param e 要添加到此数组的元素
 96      * @return <tt>true</tt> 判断添加是否成功
 97      */
 98     @Override
 99     public boolean add(E e) {
100
101         // 验证容器大小     增加计数器
102         ensureCapacityInternal(size + 1);
103         elementData[size++] = e;
104         return true;
105     }
106
107
108     /**
109      * 确保内部容量(验证容器长度是否符合)
110      *
111      * @param minCapacity 最小容量
112      */
113     private void ensureCapacityInternal(int minCapacity) {
114
115         // 容器是否满了,不满返回较大值
116         if (elementData == DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA) {
117
118             // 比较默认数组大小和最小容量
119             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
120
121         }
122
123         // 扩容数组大小
124         ensureExplicitCapacity(minCapacity);
125     }
126
127
128     /**
129      * 扩容容器大小
130      *
131      * @param minCapacity 最小容量
132      */
133     private void ensureExplicitCapacity(int minCapacity) {
134
135         // 数组被修改次数
136         modCount++;
137
138         // 容器大小范围限制,防止溢出
139         if (minCapacity - elementData.length > 0)
140         // 设置数组大小
141         {
142             grow(minCapacity);
143         }
144     }
145
146
147     /**
148      * 确保数组大小的值
149      * <p>
150      * 增加容量以确保它至少可以容纳最小容量参数指定的元素数
151      *
152      * @param minCapacity 所需的最小容量
153      */
154     private void grow(int minCapacity) {
155
156         // 设置数组大小防止溢出
157         int oldCapacity = elementData.length;
158
159         // 如果容器大小是10,即oldCapacity=10,则公式为: 1010(二进制)+101(右移一位)就是15
160         int newCapacity = oldCapacity + (oldCapacity >> 1);
161
162         if (newCapacity - minCapacity < 0)
163
164             newCapacity = minCapacity;
165
166         if (newCapacity - MAX_ARRAY_SIZE > 0)
167
168             newCapacity = hugeCapacity(minCapacity);
169
170         // 老数组拷贝到新数组中
171         elementData = Arrays.copyOf(elementData, newCapacity);
172     }
173
174
175     /**
176      * 使用较大的容量
177      *
178      * @param minCapacity 所需的最小容量
179      * @return 容量大小
180      */
181     private static int hugeCapacity(int minCapacity) {
182
183         // 所需容量是负值
184         if (minCapacity < 0) {
185             throw new OutOfMemoryError();
186         }
187
188         // 所需容量是否大于最大容量
189         return (minCapacity > MAX_ARRAY_SIZE) ?
190                 Integer.MAX_VALUE :
191                 MAX_ARRAY_SIZE;
192     }
193
194
195     /**
196      * 返回此列表中的元素数(必须有否则元素加不进去)
197      *
198      * @return 此列表中的元素数
199      */
200     @Override
201     public int size() {
202         return size;
203     }
204
205     /**
206      * 必须写要不加不进去数组
207      *
208      * @param index 数组索引
209      * @return 数组元素
210      */
211     @Override
212     public E get(int index) {
213         rangeCheck(index);
214
215         return elementData(index);
216     }
217
218     /**
219      * 核查索引
220      *
221      * @param index 此列表中的元素数
222      */
223     private void rangeCheck(int index) {
224         if (index >= size) {
225             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
226         }
227     }
228
229     /**
230      * 数组越界
231      *
232      * @param index 数组长度
233      * @return 数组长度和尺度
234      */
235     private String outOfBoundsMsg(int index) {
236         return "Index: " + index + ", Size: " + size;
237     }
238
239     /**
240      * @param index 数组索引
241      * @return 数组元素
242      */
243     private E elementData(int index) {
244         return (E) elementData[index];
245     }
246
247 }

这里就是去除了所有不属于add(),方法的代码,单独查阅,实现add()方法的代码,和add()方法使用的相关内容.

(2)ArrayList仿写测试

• 仿写ArrayList的add()方法为MyArrayList,那么,这个方法是否是正确的呢,需要通过测试,得知其是否是跟以前的版本一样是好使的.

 1 package com.synway.test.version001;
 2     import com.synway.test.collections.version001.addmethod.impl.MyArrayList;
 3     import java.util.ArrayList;
 4     import java.util.List;
 5     /**
 6      *  测试仿写的ArrayList
 7      *
 8      * @author liuyangos8888
 9     */
10
11     public class MyListTest {
12     public static void main(String[] args) {
13
14         getLikeArrayList();
15
16     }
17
18     private static void getLikeArrayList() {
19         List<String> stringList = new MyArrayList<>();
20
21         stringList.add("A");
22         stringList.add("B");
23         stringList.add("C");
24         stringList.add("D");
25         stringList.add("E");
26
27         System.out.println("stringList:" + stringList);
28     }
29  }

结果:

(3)正常ArrayList调用add()

 1 java
 2 package com.synway.test.version001;
 3
 4
 5 import com.synway.test.collections.version001.addmethod.impl.MyArrayList;
 6
 7 import java.util.ArrayList;
 8 import java.util.List;
 9
10 /**
11  * 测试仿写的ArrayList
12  *
13  * @author liuyangos8888
14  */
15 public class MyListTest {
16
17
18     public static void main(String[] args) {
19
20        getOriginArrayList();
21
22     }
23
24     private static void getOriginArrayList() {
25         List<String> stringList = new ArrayList<>();
26
27         stringList.add("A");
28         stringList.add("B");
29         stringList.add("C");
30         stringList.add("D");
31         stringList.add("E");
32
33         System.out.println("stringList:" + stringList);
34     }
35 }

结果:

(4)去除函数方法,整合查阅

• 因为源码都是根据函数方法的优化方式写的,你会看到其每几行就跳一下,每几行就跳一下,对于查阅的开始者是很难看出整个逻辑的,所以,这里本人使用了将多个函数方法合并的方式,代码这样多个函数方法,是根据优化代码的方式(《代码整洁之道》)中描述的,最好的构造方法不要超过10行,一个函数方法如果超过10行,就要对其进行函数方法的封装,每个函数方法体内只做一件事.
• 本身的函数调用关系:

• 合并方法后

    1 package com.synway.test.collections.version001.addmethod.all;
    2
    3 import java.util.AbstractList;
    4 import java.util.Arrays;
    5 import java.util.List;
    6 import java.util.RandomAccess;
    7
    8 /**
    9  * 仿写List
   10  *
   11  * @author liuyangos8888
   12  */
   13 public class AllArrayList<E> extends AbstractList<E>
   14         implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
   15
   16
   17     /**
   18      * 默认的数组大小,数组默认大小是10
   19      */
   20     private static final int DEFAULT_CAPACITY = 10;
   21
   22
   23     /**
   24      * 默认空数组的初始化
   25      */
   26     private static final Object[] EMPTY_ELEMENT_DATA = {};
   27
   28
   29     /**
   30      * 默认共享数组空间,用于区分添加第一个元素空间扩容多少
   31      */
   32     private static final Object[] DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA = {};
   33
   34
   35     /**
   36      * 存储ArrayList元素的数组缓冲区。
   37      * ArrayList的容量是此数组缓冲区的长度.
   38      * 添加第一个元素时，任何具有elementData == DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA的
   39      * 空ArrayList都将扩展为DEFAULT_CAPACITY。
   40      * <p>
   41      * <p>
   42      * 缓冲区数组,任何被赋值的数组都会变为容量为默认10的数组
   43      */
   44     transient Object[] elementData;
   45
   46
   47     /**
   48      * 包含元素的数组的大小
   49      */
   50     private int size;
   51
   52
   53     /**
   54      * 要分配的最大数组大小。
   55      * 一些虚拟机在数组中保留一些标题字。
   56      * 尝试分配更大的阵列可能会导致*
   57      * OutOfMemoryError：请求的阵列大小超出VM限制
   58      */
   59     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   60
   61
   62     /**
   63      * 构造一个初始容量为10的空数组
   64      */
   65     public AllArrayList() {
   66
   67         this.elementData = DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA;
   68     }
   69
   70     /**
   71      * 添加元素
   72      * 将指定的元素追加到此数组的末尾
   73      *
   74      * @param e 要添加到此数组的元素
   75      * @return <tt>true</tt> 判断添加是否成功
   76      */
   77     @Override
   78     public boolean add(E e) {
   79
   80         // 初始化容器大小
   81         int minCapacity = size + 1;
   82
   83         // 容器是否满了,不满返回较大值
   84         if (elementData == DEFAULT_CAPACITY_EMPTY_ELEMENT_DATA) {
   85
   86             // 比较默认数组大小和最小容量
   87             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
   88
   89         }
   90
   91         // 数组被修改次数
   92         modCount++;
   93
   94         // 容器大小范围限制,防止溢出
   95         if (minCapacity - elementData.length > 0)
   96         // 设置数组大小
   97         {
   98             // 设置数组大小防止溢出
   99             int oldCapacity = elementData.length;
  100
  101             // 如果容器大小是10,即oldCapacity=10,则公式为: 1010(二进制)+101(右移一位)就是15
  102             int newCapacity = oldCapacity + (oldCapacity >> 1);
  103
  104             if (newCapacity - minCapacity < 0) {
  105
  106                 newCapacity = minCapacity;
  107             }
  108
  109             if (newCapacity - MAX_ARRAY_SIZE > 0) {
  110
  111                 // 所需容量是负值
  112                 if (minCapacity < 0) {
  113                     throw new OutOfMemoryError();
  114                 }
  115
  116                 // 所需容量是否大于最大容量
  117                 if (minCapacity > MAX_ARRAY_SIZE) {
  118                     newCapacity = Integer.MAX_VALUE;
  119                 } else {
  120                     newCapacity = MAX_ARRAY_SIZE;
  121                 }
  122
  123             }
  124
  125             // 老数组拷贝到新数组中
  126             elementData = Arrays.copyOf(elementData, newCapacity);
  127         }
  128
  129
  130         elementData[size++] = e;
  131         return true;
  132     }
  133
  134     /**
  135      * 返回此列表中的元素数(必须有否则元素加不进去)
  136      *
  137      * @return 此列表中的元素数
  138      */
  139     @Override
  140     public int size() {
  141         return size;
  142     }
  143
  144     /**
  145      * 必须写要不加不进去数组
  146      *
  147      * @param index 数组索引
  148      * @return 数组元素
  149      */
  150     @Override
  151     public E get(int index) {
  152         rangeCheck(index);
  153
  154         return elementData(index);
  155     }
  156
  157     /**
  158      * 核查索引
  159      *
  160      * @param index 此列表中的元素数
  161      */
  162     private void rangeCheck(int index) {
  163         if (index >= size) {
  164             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  165         }
  166     }
  167
  168     /**
  169      * 数组越界
  170      *
  171      * @param index 数组长度
  172      * @return 数组长度和尺度
  173      */
  174     private String outOfBoundsMsg(int index) {
  175         return "Index: " + index + ", Size: " + size;
  176     }
  177
  178     /**
  179      * @param index 数组索引
  180      * @return 数组元素
  181      */
  182     private E elementData(int index) {
  183         return (E) elementData[index];
  184     }
  185   }

• 合并测试

   1 package com.synway.test.version001;
   2
   3
   4 import com.synway.test.collections.version001.addmethod.all.AllArrayList;
   5 import com.synway.test.collections.version001.addmethod.impl.MyArrayList;
   6
   7 import java.util.ArrayList;
   8 import java.util.List;
   9
  10 /**
  11  * 测试仿写的ArrayList
  12  *
  13  * @author liuyangos8888
  14  */
  15 public class AllListTest {
  16
  17
  18     public static void main(String[] args) {
  19
  20         getAllArrayList();
  21     }
  22
  23     private static void getAllArrayList() {
  24         List<String> stringList = new AllArrayList<>();
  25
  26         stringList.add("A");
  27         stringList.add("B");
  28         stringList.add("C");
  29         stringList.add("D");
  30         stringList.add("E");
  31
  32         System.out.println("stringList:" + stringList);
  33     }
  34
  35
  36 }

• 测试结果
  
• 补充
  涉及频繁增删使用linkedlist,涉及安全使用Vector
  
  这就是初步的改写和合并查阅方案,希望对你有帮助,感谢支持,如果有有疑问请留言,我们共同讨论