【Java心得总结六】Java容器中——Collection在前面自己总结的一篇博文中对Collection的框架结构做了整理，这里深究一下Java中list的实现方式
1.动态数组
In computer science, a dynamic array, growable array, resizable array, dynamic table, mutable array, or array list is a random access, variable-size list data structure that allows elements to be added or removed. It is supplied with standard libraries in many modern mainstream programming languages.
A dynamic array is not the same thing as a dynamically allocated array, which is a fixed-size arraywhose size is fixed when the array is allocated, although a dynamic array may use such a fixed-size array as a back end.
——维基百科
我们可以看出动态数组在动态分配数组（固定大小数组）的基础上实现的可随机存取大小可变的一种数据结构
2.Java中ArrayList实现
我截取了部分ArrayList的Java实现：
代码段1
1 public class ArrayList<E> extends AbstractList<E> 2 implements List<E>, RandomAccess, Cloneable, java.io.Serializable 3 { 4 private transient Object[] elementData; 5 6 private int size; 7 8 public ArrayList(int initialCapacity) { 9 super(); 10 if (initialCapacity < 0) 11 throw new IllegalArgumentException("Illegal Capacity: "+ 12 initialCapacity); 13 this.elementData = new Object[initialCapacity]; 14 } 15 16 public ArrayList() { 17 this(10); 18 } 19 20 public ArrayList(Collection<? extends E> c) { 21 elementData = c.toArray(); 22 size = elementData.length; 23 // c.toArray might (incorrectly) not return Object[] (see 6260652) 24 if (elementData.getClass() != Object[].class) 25 elementData = Arrays.copyOf(elementData, size, Object[].class); 26 } 27 28 private void grow(int minCapacity) { 29 // overflow-conscious code 30 int oldCapacity = elementData.length; 31 int newCapacity = oldCapacity + (oldCapacity >> 1); 32 if (newCapacity - minCapacity < 0) 33 newCapacity = minCapacity; 34 if (newCapacity - MAX_ARRAY_SIZE > 0) 35 newCapacity = hugeCapacity(minCapacity); 36 // minCapacity is usually close to size, so this is a win: 37 elementData = Arrays.copyOf(elementData, newCapacity); 38 } 39 40 private static int hugeCapacity(int minCapacity) { 41 if (minCapacity < 0) // overflow 42 throw new OutOfMemoryError(); 43 return (minCapacity > MAX_ARRAY_SIZE) ? 44 Integer.MAX_VALUE : 45 MAX_ARRAY_SIZE; 46 } 47 48 /* 增加元素 */ 49 public boolean add(E e) { 50 ensureCapacityInternal(size + 1); // Increments modCount!! 51 elementData[size++] = e; 52 return true; 53 } 54 55 public void add(int index, E element) { 56 rangeCheckForAdd(index); 57 58 ensureCapacityInternal(size + 1); // Increments modCount!! 59 System.arraycopy(elementData, index, elementData, index + 1, 60 size - index); 61 elementData[index] = element; 62 size++; 63 } 64 65 private void rangeCheckForAdd(int index) { 66 if (index > size || index < 0) 67 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 68 } 69 70 /* 删除元素 */ 71 public E remove(int index) { 72 rangeCheck(index); 73 74 modCount++; 75 E oldValue = elementData(index); 76 77 int numMoved = size - index - 1; 78 if (numMoved > 0) 79 System.arraycopy(elementData, index+1, elementData, index, 80 numMoved); 81 elementData[--size] = null; // Let gc do its work 82 83 return oldValue; 84 } 85 86 public boolean remove(Object o) { 87 if (o == null) { 88 for (int index = 0; index < size; index++) 89 if (elementData[index] == null) { 90 fastRemove(index); 91 return true; 92 } 93 } else { 94 for (int index = 0; index < size; index++) 95 if (o.equals(elementData[index])) { 96 fastRemove(index); 97 return true; 98 } 99 } 100 return false; 101 } 102 103 private void fastRemove(int index) { 104 modCount++; 105 int numMoved = size - index - 1; 106 if (numMoved > 0) 107 System.arraycopy(elementData, index+1, elementData, index, 108 numMoved); 109 elementData[--size] = null; // Let gc do its work 110 } 111 112 /* 查找元素 */ 113 public E get(int index) { 114 rangeCheck(index); 115 116 return elementData(index); 117 } 118 119 public int indexOf(Object o) { 120 if (o == null) { 121 for (int i = 0; i < size; i++) 122 if (elementData[i]==null) 123 return i; 124 } else { 125 for (int i = 0; i < size; i++) 126 if (o.equals(elementData[i])) 127 return i; 128 } 129 return -1; 130 } 131 132 public boolean contains(Object o) { 133 return indexOf(o) >= 0; 134 } 135 136 private void rangeCheck(int index) { 137 if (index >= size) 138 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); 139 } 140 141 /* 修改元素 */ 142 public E set(int index, E element) { 143 rangeCheck(index); 144 145 E oldValue = elementData(index); 146 elementData[index] = element; 147 return oldValue; 148 } 149 }
代码段2
1 public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { 2 T[] copy = ((Object)newType == (Object)Object[].class) 3 ? (T[]) new Object[newLength] 4 : (T[]) Array.newInstance(newType.getComponentType(), newLength); 5 System.arraycopy(original, 0, copy, 0, 6 Math.min(original.length, newLength)); 7 return copy; 8 }
- 代码4行，可以看出Java利用了一个Object数组来支持动态数组ArrayList的存取，Object[]的初始大小可以利用构造函数来进行设置
- 在代码28行，可以看出当Object数组不够用的时候，Java会利用grow函数对原有数组进行扩展。查看Java Arrays类会找到copyOf静态方法，会发现Java会新开辟一段更大的存储空间(newLength)，然后再将原有数组的数据全部复制到新的数组中，并返回新的引用。之后grow会将elementData指向新的数组。
- 而接下来我按照增删查改的顺序对Java中的函数进行了列举，基本就是普通的动态数组操作，就不一一说明。
3.Java中LinkedList实现
Java中LinkedList就是用双向链表来实现的，我截取了部分代码：
代码段1：
1 public class LinkedList<E> 2 extends AbstractSequentialList<E> 3 implements List<E>, Deque<E>, Cloneable, java.io.Serializable 4 { 5 transient int size = 0; 6 7 transient Node<E> first; 8 9 transient Node<E> last; 10 11 public LinkedList() { 12 } 13 14 public LinkedList(Collection<? extends E> c) { 15 this(); 16 addAll(c); 17 } 18 /* 链表基本操作 */ 19 private void linkFirst(E e) { 20 final Node<E> f = first; 21 final Node<E> newNode = new Node<>(null, e, f); 22 first = newNode; 23 if (f == null) 24 last = newNode; 25 else 26 f.prev = newNode; 27 size++; 28 modCount++; 29 } 30 31 void linkLast(E e) { 32 final Node<E> l = last; 33 final Node<E> newNode = new Node<>(l, e, null); 34 last = newNode; 35 if (l == null) 36 first = newNode; 37 else 38 l.next = newNode; 39 size++; 40 modCount++; 41 } 42 43 void linkBefore(E e, Node<E> succ) { 44 // assert succ != null; 45 final Node<E> pred = succ.prev; 46 final Node<E> newNode = new Node<>(pred, e, succ); 47 succ.prev = newNode; 48 if (pred == null) 49 first = newNode; 50 else 51 pred.next = newNode; 52 size++; 53 modCount++; 54 } 55 56 private E unlinkFirst(Node<E> f) { 57 // assert f == first && f != null; 58 final E element = f.item; 59 final Node<E> next = f.next; 60 f.item = null; 61 f.next = null; // help GC 62 first = next; 63 if (next == null) 64 last = null; 65 else 66 next.prev = null; 67 size--; 68 modCount++; 69 return element; 70 } 71 72 private E unlinkLast(Node<E> l) { 73 // assert l == last && l != null; 74 final E element = l.item; 75 final Node<E> prev = l.prev; 76 l.item = null; 77 l.prev = null; // help GC 78 last = prev; 79 if (prev == null) 80 first = null; 81 else 82 prev.next = null; 83 size--; 84 modCount++; 85 return element; 86 } 87 88 E unlink(Node<E> x) { 89 // assert x != null; 90 final E element = x.item; 91 final Node<E> next = x.next; 92 final Node<E> prev = x.prev; 93 94 if (prev == null) { 95 first = next; 96 } else { 97 prev.next = next; 98 x.prev = null; 99 } 100 101 if (next == null) { 102 last = prev; 103 } else { 104 next.prev = prev; 105 x.next = null; 106 } 107 108 x.item = null; 109 size--; 110 modCount++; 111 return element; 112 } 113 114 /* 查找操作 */ 115 public int indexOf(Object o) { 116 int index = 0; 117 if (o == null) { 118 for (Node<E> x = first; x != null; x = x.next) { 119 if (x.item == null) 120 return index; 121 index++; 122 } 123 } else { 124 for (Node<E> x = first; x != null; x = x.next) { 125 if (o.equals(x.item)) 126 return index; 127 index++; 128 } 129 } 130 return -1; 131 } 132 133 public int lastIndexOf(Object o) { 134 int index = size; 135 if (o == null) { 136 for (Node<E> x = last; x != null; x = x.prev) { 137 index--; 138 if (x.item == null) 139 return index; 140 } 141 } else { 142 for (Node<E> x = last; x != null; x = x.prev) { 143 index--; 144 if (o.equals(x.item)) 145 return index; 146 } 147 } 148 return -1; 149 } 150 151 /*添加操作*/ 152 public boolean addAll(int index, Collection<? extends E> c) { 153 checkPositionIndex(index); 154 155 Object[] a = c.toArray(); 156 int numNew = a.length; 157 if (numNew == 0) 158 return false; 159 160 Node<E> pred, succ; 161 if (index == size) { 162 succ = null; 163 pred = last; 164 } else { 165 succ = node(index); 166 pred = succ.prev; 167 } 168 169 for (Object o : a) { 170 @SuppressWarnings("unchecked") E e = (E) o; 171 Node<E> newNode = new Node<>(pred, e, null); 172 if (pred == null) 173 first = newNode; 174 else 175 pred.next = newNode; 176 pred = newNode; 177 } 178 179 if (succ == null) { 180 last = pred; 181 } else { 182 pred.next = succ; 183 succ.prev = pred; 184 } 185 186 size += numNew; 187 modCount++; 188 return true; 189 } 190 191 public boolean add(E e) { 192 linkLast(e); 193 return true; 194 } 195 196 /* 删除操作 */ 197 public E removeFirst() { 198 final Node<E> f = first; 199 if (f == null) 200 throw new NoSuchElementException(); 201 return unlinkFirst(f); 202 } 203 204 public E removeLast() { 205 final Node<E> l = last; 206 if (l == null) 207 throw new NoSuchElementException(); 208 return unlinkLast(l); 209 } 210 211 /* 修改操作 */ 212 public E set(int index, E element) { 213 checkElementIndex(index); 214 Node<E> x = node(index); 215 E oldVal = x.item; 216 x.item = element; 217 return oldVal; 218 } 219 }
代码段2：
1 private static class Node<E> { 2 E item; 3 Node<E> next; 4 Node<E> prev; 5 6 Node(Node<E> prev, E element, Node<E> next) { 7 this.item = element; 8 this.next = next; 9 this.prev = prev; 10 } 11 }
- 代码段1的7行和9行，我们可以看到Java中LinkedList的实现就是我们所熟知的双向链表数据结构，并且声明了头指针和尾指针分别指向链表的头和尾
- 每个节点的结构见代码段2，发现是基本的双向链表节点结构
- 而从代码18行开始就是常规的链表操作，包括插入结点和删除结点的操作
- 而之后的增删查改操作大都是利用基本的链表操作实现的
- 另外，值得注意的是LinkedList在Java中还有一个特殊功效就是通过向上转型当做队列Queue来使用
如下面这段代码
Queue<Integer> queue = new LinkedList<Integer>();
这里向上转型无非是将LinkedList限制为头尾读取。
Java中的动态数组实现，比较简单，复习回顾下，做下记录^v^