Java1.8集合源码：ArrayList 详细解析
来源：互联网 发布：手机怎么还原网络设置 编辑：程序博客网 时间：2024/05/16 06:48
一.ArrayList
1. 重点概念归纳
- List接口的可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。
- 非线程安全。在多线程情况下操作时，一定要加上synchronized，才能保证多个线程同时对ArrayList进行访问时数据的安全性。
- 底层使用的数据结构是数组。
- 适合查改，弱于增删。
- 实现了Serializable接口，因此它支持序列化，能够通过序列化传输。
- 实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问。
- 实现了Cloneable接口，能被克隆。
2. ArrayList源码详细注释解读
代码自己逐个方法、重要的地方都标明了中文注释，可以直接阅读代码，后面会详细分析。（注意：关于ArrayList类相比较旧版本是有改动的，此文研究的是1.7版本的源码！后面也会大致分析新旧版本的区别，自己是对照了新旧版本一点点改的）
package java.util; public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { // 序列版本号 private static final long serialVersionUID = 8683452581122892189L; //默认列表容量 private static final int DEFAULT_CAPACITY = 10; //用于空实例的共享空数组实例 private static final Object[] EMPTY_ELEMENTDATA = {}; //用于默认大小的空实例的共享空数组实例，与EMPTY_ELEMENTDATA不同，当添加第一个元素时知道扩容多少 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * ArrayList基于该数组实现，用该数组保存数据 * 不置为私有域是为了方便嵌套类访问 */ transient Object[] elementData; // ArrayList中实际数据的数量 private int size; // ArrayList的构造函数，有明确的容量要求 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); } } // ArrayList无参构造函数 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } // 创建一个包含collection的ArrayList，为了返回 collection的迭代器 public 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; } } // 修改这ArrayList实例的容量，将当前容量值设为实际元素个数 public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } } //------------------------------------ start --------------- /** * 增加ArrayList实例的容量，确保它至少可以容纳元素的数量，数量由最小容量参数指定 * * @param minCapacity 最小容量 */ 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) ensureCapacityInternal(minCapacity); } private void ensureCapacityInternal(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) //若传入的要求容量大小大于列表目前大小，则调用grow方法增容 grow(minCapacity); } /** * 可分配给数组的最大容量 * * 尝试分配较大的数组可能会导致OutOfMemoryError：请求的数组大小超过VM限制 */ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; /** * 增加容量，以确保它至少能够容纳最小容量参数指定的元素数 * * @param minCapacity 最小容量 */ 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) //若计算的新容量大于规定列表最大值，则调用hugeCapacity方法 newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } //当grow中算法计算的新容器值大于规定最大值，则比较参数值和规定最大值，返回两者最小值 private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } //------------------------------------ end --------------- // 返回ArrayList的实际大小 public int size() { return size; } //返回ArrayList是否为空 public boolean isEmpty() { return size == 0; } // ArrayList是否包含Object(o) public boolean contains(Object o) { return indexOf(o) >= 0; } // 正向查找，返回指定元素的第一次出现的索引，如果此列表不包含元素，则为-1 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; } // 反向查找(从数组末尾向开始查找)，返回元素(o)的索引值 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; } // 克隆函数 public Object clone() { try { ArrayList<E> v = (ArrayList<E>) super.clone(); // 将当前ArrayList的全部元素拷贝到v中 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元素组成的数组 @SuppressWarnings("unchecked") public <T> T[] toArray(T[] a) { // 若数组a的大小 < ArrayList的元素个数； // 则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中 if (a.length < size) return (T[]) Arrays.copyOf(elementData, size, a.getClass()); // 若数组a的大小 >= ArrayList的元素个数； // 则将ArrayList的全部元素都拷贝到数组a中。 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]; } // 获取index位置的元素值 public E get(int index) { rangeCheck(index); return (E) elementData[index]; } // 设置index位置的值为element 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); //如果列表长度不足，进行扩容。 elementData[size++] = e; return true; } // 将e添加到ArrayList的指定位置 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++; } // 删除ArrayList指定位置的元素 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; // GC垃圾回收期会回收无引用对象 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 { // 遍历ArrayList，找到“元素o”，则删除，并返回true。 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; // 从"index+1"开始，用后面的元素替换前面的元素。 if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); // 将最后一个元素设为null elementData[--size] = null; // Let gc do its work } // 清空ArrayList，将全部的元素设为null public void clear() { modCount++; for (int i = 0; i < size; i++) elementData[i] = null; size = 0; } // 将集合c追加到ArrayList中 public boolean addAll(Collection<? extends E> c) { rangeCheckForAdd(index); //新版本增加的 Object[] a = c.toArray(); int numNew = a.length; ensureCapacity(size + numNew); //如果列表长度不足，进行扩容。 System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } // 从index位置开始，将集合c添加到ArrayList 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); //如果列表长度不足，进行扩容。 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; } // 删除fromIndex到toIndex之间的全部元素。 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; } //检查下标是否超出范围 private void rangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } /** 新版本增加的 * 此版本被用于 add 和 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) { return batchRemove(c, false); } //仅保留此列表中指定集合包含的元素，换句话说，从这个列表中删除所有不包含在指定的集合中的元素。 public boolean retainAll(Collection<?> c) { return batchRemove(c, true); } private boolean batchRemove(Collection<?> c, boolean complement) { final Object[] elementData = this.elementData; int r = 0, w = 0; boolean modified = false; try { for (; r < size; r++) if (c.contains(elementData[r]) == complement) elementData[w++] = elementData[r]; } finally { // Preserve behavioral compatibility with AbstractCollection, // even if c.contains() throws. if (r != size) { System.arraycopy(elementData, r, elementData, w, size - r); w += size - r; } if (w != size) { for (int i = w; i < size; i++) elementData[i] = null; modCount += size - w; size = w; modified = true; } } return modified; } /* * java.io.Serializable的写入函数 * 将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(); // 写入“数组的容量” s.writeInt(elementData.length); // 写入“数组的每一个元素” for (int i=0; i<size; i++) s.writeObject(elementData[i]); if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } // java.io.Serializable的读取函数：根据写入方式读出 // 先将ArrayList的“容量”读出，然后将“所有的元素值”读出 private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in size, and any hidden stuff s.defaultReadObject(); // 从输入流中读取ArrayList的“容量” int arrayLength = s.readInt(); Object[] a = elementData = new Object[arrayLength]; // 从输入流中将“所有的元素值”读出 for (int i=0; i<size; i++) a[i] = s.readObject(); } //返回列表中的列表迭代器 public ListIterator<E> listIterator(int index) { if (index < 0 || index > size) throw new IndexOutOfBoundsException("Index: "+index); return new ListItr(index); } ...... //有关获取迭代器的代码就不贴了}3. 源码重点解析
以下介绍ArrayList源码中常见且重点的8个方法，了解后基本已经可以掌握ArrayList源码精髓了，来一探究竟：
（1）构造函数
ArrayList类有三个重载的构造方法：
ArrayList()
无参数默认构造方法，创建列表（即数组)的容量大小默认为10。ArrayList(int initialCapacity)
带有int参数的构造方法，参数为创建列表时要求容量，创建一个大小为initialCapacity的列表。ArrayList( Collection< ? extends E > c)
带有Collection参数的构造方法，将Collection转化为数组赋给ArrayList的实现数组elementData。
（2）ensureCapacity 方法
此方法比较重要，需重视。功能为扩充容量，在每次对列表进行有关添加的操作都会调用此方法为数组扩容。ArrayList在每次增加元素时（调用add方法时是增加1个元素，即传入的参数是当前总数+1，调用addAll方法时增加一组元素，传入方法参数是当前总数+一组总数），都要调用该方法来确保足够的容量。
决定扩容后最新容量值的逻辑
参考代码具体实现，首先类中有个常量MAX_ARRAY_SIZE，它是可分配给数组的最大容量，为Integer.MAX_VALUE - 8，是一个很大的数值了。在继续之前ensureCapacity方法有个算法：根据列表当前容量大小，采用右位移运算符将数值二进制移动一位，得到一位新值（肯定会比列表当前容量大）。注意：旧版本中计算此数值的算法是：新的容量为列表当前容量的1.5倍加1。将计算的新容量值和参数容量值进行比较，如果小于参数容量值，则以参数容量值为准进行扩容；反之当计算的新容量值大于规定值时，不能这么轻易的将它决定为最终结果，会继续判断参数规定值是否小于0（如果是的情况下计算值总会大于规定值，则抛出异常），然后继续判断计算值是否大于最大限制值（不可超出最大限制值）
性能
以上过程就是决定扩容后的最新容量值的逻辑，决定好后用Arrays.copyof()方法将元素拷贝到新的数组（详见下面的第3点）。可以看出，因为ArrayList底层是动态数组，创建时确定好容量数值后，每次不够需要扩容时，都需要将原来的元素拷贝到一个新的数组中，这是一个非常耗时的过程。因此从性能方面考虑，建议在能够确定容量大小的情况下采用ArrayList，不确定的情况下采用LinkedList。
（3）Arrays.copyof() 方法和 System.arraycopy() 方法
在上一点已经提到过此方法，ArrayList的实现中大量地调用了，功能即将元素拷贝到新的数组。来查看其代码实现，这里有多个重载方法，实现思路相同，来看其中一个即可：
public static <T> T[] copyOf(T[] original, int newLength) { return (T[]) copyOf(original, newLength, original.getClass()); }public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { 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; } 所以其实真正调用的是copyOf()方法，可以看出该方法实际上是在其内部又创建了一个长度为newlength的数组，调用System.arraycopy()方法，将原来数组中的元素复制到了新的数组中。
而System.arraycopy()方法被标记为native，调用了系统的C/C++代码，只能在openJDK中查看源码。这里简单说明一下，此方法实际上调用了C语言的memmove()函数，所以它可以保证同一个数组内元素的正确复制和移动，效率比一般的复制方法高，适合用于批量处理数组。在Java中也比较推荐使用此方法达到更好的效率。
（4）toArray 方法
ArrayList中有两个实现toArray 转化为静态数组的方法：
public Object[] toArray()
此方法直接调用Arrays.copyof()并将结果返回，这样做有潜在危机，有可能会抛出ClassCastException异常。例如：直接用向下转型的方法，将整个ArrayList集合转变为指定类型的Array数组，便会抛出该异常。但是，如果转化为Array数组时不向下转型，而是将每个元素向下转型，则不会抛出该异常。这样的做法明显效率低下，且不太方便。public T[] toArray(T[] a)
方法一开始会进行判断，若数组a的容量个数小于ArrayList的元素个数，则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中 。反之则将ArrayList的全部元素都拷贝到数组a中。该方法可以直接将ArrayList转换得到的Array进行整体向下转型，效率较高。
（5）add 增加方法
add(E e)
功能就是将新元素增加到列表尾部。照例，首先调用ensureCapacity方法来确保容量是否满足，即确保列表中还有额外的一个容量，然后将列表的末尾值设置为新值，返回True代表成功。add(int index, E element)
不同于上一个函数将新元素直接增加到列表尾部，此功能是将新元素增加到指定位置index。来查看方法实现，由于都是增加元素必然会调用到ensureCapacity方法来确保容量是否满足，可是在此操作之前还需判断index是否合法（指定下标小于0或大于列表总长度）。一切准备就绪开始插入元素，注意ArrayList底层原理是数组，所以需要将列表中index后的元素全部往后移动一位，空出一个位置留给新元素，这里就用到上面介绍到的System.arraycopy()方法进行元素拷贝。最后赋值、总长度加1即完成操作。
（6）remove 删除方法
remove(int index)
功能即移除此列表中指定位置上的元素。来查看方法实现，照例，首先判断下标是否合法，然后同增加方法一样，需要将列表中index后的值全部向前移动一位，调用System.arraycopy()方法进行元素拷贝，最后将列表中最后一个元素赋值null，这里不需要担心此对象占用空间，因为GC会处理无引用对象。remove(Object o)
功能为删除ArrayList的指定元素，注意这里是以指定元素去删除列表中元素。实现方法稍有不同，首先会判断参数是否为null，如为null它并不会报错，因为存在列表中有元素为null的情况，这时开始遍历列表，移除找到的第一个值为null的元素；为不为null则遍历比较是否有相同元素，没有返回False，反之则移除，返回TRue，移除方法与上述remove(int index)相同，在此不赘述。
（7）set 修改方法
- set(int index, E element)
功能就是把这个列表上某一个元素的值进行变更修改。首先检查修改的index下标是否合法，即检查下标是否越界，然后将列表中原index的值取出保存到oldValue中返回，将值设置为更新的新值。很普通的数组修改值实现，并无太大难度。
（8）get 查找方法
- get(int index)
功能为根据下标返回列表中对应元素。首先会检查下表是否合法，然后由于列表底层由数组实现，所以直接将下标对应值返回即可。
4. 新旧版本比较
（1）ensureCapacity 扩容方法的算法
相信了解了以上只是点后，读者认识到了扩容方法ensureCapacity的重要性，然后，在旧版本中该方法的主要逻辑却有些不同，来看该方法的旧版本实现：
【旧版本】 // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1” public void ensureCapacity(int minCapacity) { // 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的 modCount++; int oldCapacity = elementData.length; // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1” if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; //如果还不够，则直接将minCapacity设置为当前容量 if (newCapacity < minCapacity) newCapacity = minCapacity; elementData = Arrays.copyOf(elementData, newCapacity); } }核心算法
首先我们直接看newCapacity 这个变量，它是根据列表当前容量经过算法计算后得到的新值，旧版本中的算法是：新的容量值为列表当前容量的1.5倍加1。而新版本中的算法：根据列表当前容量大小，采用右位移运算符将数值二进制移动一位，得到一位新值。
这样的做法明显是优化了该方法，采取更适合的方法去计算这个新容量值。
核心逻辑
可已看出，旧版本中的逻辑比较简单，当前容量不满足规定容量时，根据算法去计算新值，以新值和规定值中的最大值为准。而新版本中引入了一个列表容量的最大限制常量值MAX_ARRAY_SIZE，在旧版本的逻辑基础上多加了一步，即当计算的值大于规定值时，不能这么轻易的将它设置成新容量值，会继续判断参数规定值是否小于0（如果是的情况下计算值总会大于规定值，则抛出异常），然后继续判断计算值是否大于最大限制值（不可超出最大限制值）。
相较于旧版本，新版本中的逻辑判断更加严密，对数值的边界值、不规范等情况更方面都做了考虑。
（2）方法单独封装
这一点就是有关于Java编程规范相关的内容了，我在对照新旧版本时发现明显不同的一点，比如ensureCapacity方法，旧版本直接一个方法将所有逻辑写完，而在新版本中分解成了3个方法去实现，每个方法分工明确、职责单一，提供了更清晰的单独方法封装；还有个例子，判断参数是否符合规范，在旧版本中的if判断直接在逻辑方法中，在新版本却把它独立出作为一个方法判断，代码如下：
/** 新版本增加的 * 此版本被用于 add 和 addAll. */ private void rangeCheckForAdd(int index) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }即使只是一个简单的if判断，你可能觉得加到方法中也无可厚非，但是大量重复代码积累会显得程序冗长，所以需要时应该讲单独职责的方法封装出来，这样各方法之间分工明确，也更符合设计原则中的单一职责概念。
（3）命名规范
这是一个很基本的概念，涉及到变量、方法的命名规范，在旧版本中却有这样的方法定义：
private void RangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException( "Index: "+index+", Size: "+size); } 没错，该方法名开头字母是大写，对此我也有些不解，在新版本中已经改为小写。关于命名规范，阿里已经发布过相关规则，大家遵从这些基本规则会养成良好的代码习惯，对以后编程有很大帮助。
（4）新增内部类
在ArrayList中获取迭代器iterator的方法中，方法体统一返回的都是匿名内部类，而类实现是ArrayList中的内部类，代码如下：
public Iterator<E> iterator() { return new Itr(); } private class Itr implements Iterator<E> { int cursor; // index of next element to return ...... }（关于迭代器这一块我没有贴代码，感兴趣的可以直接去看源码）
如有错误，望指教~
希望对你们有帮助：）
- Java1.8集合源码：ArrayList 详细解析
- java1.8 常用集合源码学习：ArrayList
- ArrayList集合源码解析
- 源码解析-集合-ArrayList
- 【Java1.7.5集合源码剖析】ArrayList源码剖析
- ArrayList源码分析（基于Java1.8）
- 源码解析 ThreadPoolExecutor JAVA1.8
- Java集合源码解析-ArrayList
- Java集合ArrayList源码解析
- java1.8 常用集合源码学习：HashMap
- java1.8 常用集合源码学习：HashSet
- java1.8 常用集合源码学习：LinkedHashMap
- java1.8 常用集合源码学习：LinkedHashSet
- java1.8 常用集合源码学习：ArrayDeque
- java1.8 常用集合源码学习：PriorityQueue
- java1.8 常用集合源码学习：LinkedList
- java1.8 常用集合源码学习：TreeMap
- java1.8 常用集合源码学习：TreeSet
- 使用开源的PullToRefreshScrollView scrollTo和scrollby遇到的问题
- spark常见问题
- 九宫格手势锁
- 求二叉树中结点值的和为指定整数的所有路径
- linux环境下weblogic 部署程序出现java.util,zip.ZpException:error in opening zip file
- Java1.8集合源码：ArrayList 详细解析
- JSP 点击量统计
- ssh 无密码验证 及 ssh localhost 仍然需要密码的解决方案
- $.ajax()方法详解
- 阿里云搭建ngrok服务器
- vue.js 之根据输入的内容新增约束条件
- 递归之二分算法
- 开发设计模式——单例模式
- parseInt(),parseFloat;isNaN()
