Java中常用的List子类主要有：ArrayList、LinkedList、Vector。有序（存储和取出的元素一致），可重复的。
三者比较
1：访问：ArrayList和Vector都实现了RandomAccess接口，提供了随机访问功能，查询O（1）;LinkedList是链表，查询O（n）;
2：增删：ArrayList和Vector底层是数组，增删容易引起大量的内存操作，效率较慢；LinkedList是链表实现，增加和删除较快；
3：线程安全性：Vector是线程安全的，大部分的方法都用了syncrhoized关键字修饰。如果是单线程下使用，可以用Arrayist，如果是多线程操作的list，则可以用Vector来保证线程安全。
4：ArrayList每次扩容增加50%，Vector扩容增加一倍。
一：ArrayList
ArrayList实现了List接口，实现了一系列的add()/get()/clear()/remove()等接口中的方法。其底层其实是一个数组，通过对数组上一系列操作的封装来实现list的各种功能的。
1：ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10。
2：当ArrayList容量不足以容纳全部元素时，ArrayList扩容：新的容量=“(原始容量x3)/2 + 1”。创建新容量大小的数组并把原数组内容复制过去。
3：底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
底层源码：
1 package java.util;
2
3 public class ArrayList<E> extends AbstractList<E>
4 implements List<E>, RandomAccess, Cloneable, java.io.Serializable
5 {
6 // 序列版本号
7 private static final long serialVersionUID = 8683452581122892189L;
8
9 // 保存ArrayList中数据的数组
10 private transient Object[] elementData;
11
12 // ArrayList中实际数据的数量
13 private int size;
14
15 // ArrayList带容量大小的构造函数。
16 public ArrayList(int initialCapacity) {
17 super();
18 if (initialCapacity < 0)
19 throw new IllegalArgumentException("Illegal Capacity: "+
20 initialCapacity);
21 // 新建一个数组
22 this.elementData = new Object[initialCapacity];
23 }
24
25 // ArrayList构造函数。默认容量是10。
26 public ArrayList() {
27 this(10);
28 }
29
30 // 创建一个包含collection的ArrayList
31 public ArrayList(Collection<? extends E> c) {
32 elementData = c.toArray();
33 size = elementData.length;
34 // c.toArray might (incorrectly) not return Object[] (see 6260652)
35 if (elementData.getClass() != Object[].class)
36 elementData = Arrays.copyOf(elementData, size, Object[].class);
37 }
38
39
40 // 将当前容量值设为 =实际元素个数
41 public void trimToSize() {
42 modCount++;
43 int oldCapacity = elementData.length;
44 if (size < oldCapacity) {
45 elementData = Arrays.copyOf(elementData, size);
46 }
47 }
48
49
50 // 确定ArrarList的容量。
51 // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”
52 public void ensureCapacity(int minCapacity) {
53 // 将“修改统计数”+1
54 modCount++;
55 int oldCapacity = elementData.length;
56 // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
57 if (minCapacity > oldCapacity) {
58 Object oldData[] = elementData;
59 int newCapacity = (oldCapacity * 3)/2 + 1;
60 if (newCapacity < minCapacity)
61 newCapacity = minCapacity;
62 elementData = Arrays.copyOf(elementData, newCapacity);
63 }
64 }
65
66 // 添加元素e
67 public boolean add(E e) {
68 // 确定ArrayList的容量大小
69 ensureCapacity(size + 1); // Increments modCount!!
70 // 添加e到ArrayList中
71 elementData[size++] = e;
72 return true;
73 }
74
75 // 返回ArrayList的实际大小
76 public int size() {
77 return size;
78 }
79
80 // 返回ArrayList是否包含Object(o)
81 public boolean contains(Object o) {
82 return indexOf(o) >= 0;
83 }
84
85 // 返回ArrayList是否为空
86 public boolean isEmpty() {
87 return size == 0;
88 }
89
90 // 正向查找，返回元素的索引值
91 public int indexOf(Object o) {
92 if (o == null) {
93 for (int i = 0; i < size; i++)
94 if (elementData[i]==null)
95 return i;
96 } else {
97 for (int i = 0; i < size; i++)
98 if (o.equals(elementData[i]))
99 return i;
100 }
101 return -1;
102 }
103
104 // 反向查找，返回元素的索引值
105 public int lastIndexOf(Object o) {
106 if (o == null) {
107 for (int i = size-1; i >= 0; i--)
108 if (elementData[i]==null)
109 return i;
110 } else {
111 for (int i = size-1; i >= 0; i--)
112 if (o.equals(elementData[i]))
113 return i;
114 }
115 return -1;
116 }
117
118 // 反向查找(从数组末尾向开始查找)，返回元素(o)的索引值
119 public int lastIndexOf(Object o) {
120 if (o == null) {
121 for (int i = size-1; i >= 0; i--)
122 if (elementData[i]==null)
123 return i;
124 } else {
125 for (int i = size-1; i >= 0; i--)
126 if (o.equals(elementData[i]))
127 return i;
128 }
129 return -1;
130 }
131
132
133 // 返回ArrayList的Object数组
134 public Object[] toArray() {
135 return Arrays.copyOf(elementData, size);
136 }
137
138 // 返回ArrayList的模板数组。所谓模板数组，即可以将T设为任意的数据类型
139 public <T> T[] toArray(T[] a) {
140 // 若数组a的大小 < ArrayList的元素个数；
141 // 则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中
142 if (a.length < size)
143 return (T[]) Arrays.copyOf(elementData, size, a.getClass());
144
145 // 若数组a的大小 >= ArrayList的元素个数；
146 // 则将ArrayList的全部元素都拷贝到数组a中。
147 System.arraycopy(elementData, 0, a, 0, size);
148 if (a.length > size)
149 a[size] = null;
150 return a;
151 }
152
153 // 获取index位置的元素值
154 public E get(int index) {
155 RangeCheck(index);
156
157 return (E) elementData[index];
158 }
159
160 // 设置index位置的值为element
161 public E set(int index, E element) {
162 RangeCheck(index);
163
164 E oldValue = (E) elementData[index];
165 elementData[index] = element;
166 return oldValue;
167 }
168
169 // 将e添加到ArrayList中
170 public boolean add(E e) {
171 ensureCapacity(size + 1); // Increments modCount!!
172 elementData[size++] = e;
173 return true;
174 }
175
176 // 将e添加到ArrayList的指定位置
177 public void add(int index, E element) {
178 if (index > size || index < 0)
179 throw new IndexOutOfBoundsException(
180 "Index: "+index+", Size: "+size);
181
182 ensureCapacity(size+1); // Increments modCount!!
183 System.arraycopy(elementData, index, elementData, index + 1,
184 size - index);
185 elementData[index] = element;
186 size++;
187 }
188
189 // 删除ArrayList指定位置的元素
190 public E remove(int index) {
191 RangeCheck(index);
192
193 modCount++;
194 E oldValue = (E) elementData[index];
195
196 int numMoved = size - index - 1;
197 if (numMoved > 0)
198 System.arraycopy(elementData, index+1, elementData, index,
199 numMoved);
200 elementData[--size] = null; // Let gc do its work
201
202 return oldValue;
203 }
204
205 // 删除ArrayList的指定元素
206 public boolean remove(Object o) {
207 if (o == null) {
208 for (int index = 0; index < size; index++)
209 if (elementData[index] == null) {
210 fastRemove(index);
211 return true;
212 }
213 } else {
214 for (int index = 0; index < size; index++)
215 if (o.equals(elementData[index])) {
216 fastRemove(index);
217 return true;
218 }
219 }
220 return false;
221 }
222
223
224 // 快速删除第index个元素
225 private void fastRemove(int index) {
226 modCount++;
227 int numMoved = size - index - 1;
228 // 从"index+1"开始，用后面的元素替换前面的元素。
229 if (numMoved > 0)
230 System.arraycopy(elementData, index+1, elementData, index,
231 numMoved);
232 // 将最后一个元素设为null
233 elementData[--size] = null; // Let gc do its work
234 }
235
236 // 删除元素
237 public boolean remove(Object o) {
238 if (o == null) {
239 for (int index = 0; index < size; index++)
240 if (elementData[index] == null) {
241 fastRemove(index);
242 return true;
243 }
244 } else {
245 // 便利ArrayList，找到“元素o”，则删除，并返回true。
246 for (int index = 0; index < size; index++)
247 if (o.equals(elementData[index])) {
248 fastRemove(index);
249 return true;
250 }
251 }
252 return false;
253 }
254
255 // 清空ArrayList，将全部的元素设为null
256 public void clear() {
257 modCount++;
258
259 for (int i = 0; i < size; i++)
260 elementData[i] = null;
261
262 size = 0;
263 }
264
265 // 将集合c追加到ArrayList中
266 public boolean addAll(Collection<? extends E> c) {
267 Object[] a = c.toArray();
268 int numNew = a.length;
269 ensureCapacity(size + numNew); // Increments modCount
270 System.arraycopy(a, 0, elementData, size, numNew);
271 size += numNew;
272 return numNew != 0;
273 }
274
275 // 从index位置开始，将集合c添加到ArrayList
276 public boolean addAll(int index, Collection<? extends E> c) {
277 if (index > size || index < 0)
278 throw new IndexOutOfBoundsException(
279 "Index: " + index + ", Size: " + size);
280
281 Object[] a = c.toArray();
282 int numNew = a.length;
283 ensureCapacity(size + numNew); // Increments modCount
284
285 int numMoved = size - index;
286 if (numMoved > 0)
287 System.arraycopy(elementData, index, elementData, index + numNew,
288 numMoved);
289
290 System.arraycopy(a, 0, elementData, index, numNew);
291 size += numNew;
292 return numNew != 0;
293 }
294
295 // 删除fromIndex到toIndex之间的全部元素。
296 protected void removeRange(int fromIndex, int toIndex) {
297 modCount++;
298 int numMoved = size - toIndex;
299 System.arraycopy(elementData, toIndex, elementData, fromIndex,
300 numMoved);
301
302 // Let gc do its work
303 int newSize = size - (toIndex-fromIndex);
304 while (size != newSize)
305 elementData[--size] = null;
306 }
307
308 private void RangeCheck(int index) {
309 if (index >= size)
310 throw new IndexOutOfBoundsException(
311 "Index: "+index+", Size: "+size);
312 }
313
314
315 // 克隆函数
316 public Object clone() {
317 try {
318 ArrayList<E> v = (ArrayList<E>) super.clone();
319 // 将当前ArrayList的全部元素拷贝到v中
320 v.elementData = Arrays.copyOf(elementData, size);
321 v.modCount = 0;
322 return v;
323 } catch (CloneNotSupportedException e) {
324 // this shouldn't happen, since we are Cloneable
325 throw new InternalError();
326 }
327 }
328
329
330 // java.io.Serializable的写入函数
331 // 将ArrayList的“容量，所有的元素值”都写入到输出流中
332 private void writeObject(java.io.ObjectOutputStream s)
333 throws java.io.IOException{
334 // Write out element count, and any hidden stuff
335 int expectedModCount = modCount;
336 s.defaultWriteObject();
337
338 // 写入“数组的容量”
339 s.writeInt(elementData.length);
340
341 // 写入“数组的每一个元素”
342 for (int i=0; i<size; i++)
343 s.writeObject(elementData[i]);
344
345 if (modCount != expectedModCount) {
346 throw new ConcurrentModificationException();
347 }
348
349 }
350
351
352 // java.io.Serializable的读取函数：根据写入方式读出
353 // 先将ArrayList的“容量”读出，然后将“所有的元素值”读出
354 private void readObject(java.io.ObjectInputStream s)
355 throws java.io.IOException, ClassNotFoundException {
356 // Read in size, and any hidden stuff
357 s.defaultReadObject();
358
359 // 从输入流中读取ArrayList的“容量”
360 int arrayLength = s.readInt();
361 Object[] a = elementData = new Object[arrayLength];
362
363 // 从输入流中将“所有的元素值”读出
364 for (int i=0; i<size; i++)
365 a[i] = s.readObject();
366 }
367 }Java中对ArrayList集合的常用操作
1.list中添加，获取，删除元素；
2.list中是否包含某个元素；
3.list中根据索引将元素数值改变(替换)；
4.list中查看（判断）元素的索引；
5.根据元素索引位置进行的判断；
6.利用list中索引位置重新生成一个新的list（截取集合）；
7.对比两个list中的所有元素；
8.判断list是否为空；
9.返回Iterator集合对象；
10.将集合转换为字符串；
11.将集合转换为数组；
12.集合类型转换；
备注：内容中代码具有关联性。
1.list中添加，获取，删除元素；
添加方法是：.add(e)；
获取方法是：.get(index)；
按照索引删除方法是：.remove(index)
按照元素内容删除方法是：.remove(Object o)；
List<String> person=new ArrayList<>();
person.add("jackie"); //索引为0 //.add(e)
person.add("peter"); //索引为1
person.add("annie"); //索引为2
person.add("martin"); //索引为3
person.add("marry"); //索引为4
person.remove(3); //.remove(index)
person.remove("marry"); //.remove(Object o)
String per="";
per=person.get(1);
System.out.println(per); //.get(index)
for (int i = 0; i < person.size(); i++) {
System.out.println(person.get(i)); //.get(index)
}
2.list中是否包含某个元素；
方法：.contains(Object o)； 返回true或者false
List<String> fruits=new ArrayList<>();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("桃子");
//for循环遍历list
for (int i = 0; i < fruits.size(); i++) {
System.out.println(fruits.get(i));
}
String appleString="苹果";
//true or false
System.out.println("fruits中是否包含苹果："+fruits.contains(appleString));
if (fruits.contains(appleString)) {
System.out.println("我喜欢吃苹果");
}else {
System.out.println("我不开心");
}
3.list中根据索引将元素数值改变(替换)；
注意 .set(index, element); 和 .add(index, element); 的不同；
String a="白龙马", b="沙和尚", c="八戒", d="唐僧", e="悟空";
List<String> people=new ArrayList<>();
people.add(a);
people.add(b);
people.add(c);
people.set(0, d); //.set(index, element); //将d唐僧放到list中索引为0的位置，替换a白龙马
people.add(1, e); //.add(index, element); //将e悟空放到list中索引为1的位置,原来位置的b沙和尚后移一位
//增强for循环遍历list
for(String str:people){
System.out.println(str);
}
4.list中查看（判断）元素的索引；
注意：indexOf()和lastIndexOf()的不同；
List<String> names=new ArrayList<>();
names.add("刘备"); //索引为0
names.add("关羽"); //索引为1
names.add("张飞"); //索引为2
names.add("刘备"); //索引为3
names.add("张飞"); //索引为4
System.out.println(names.indexOf("刘备"));
System.out.println(names.lastIndexOf("刘备"));
System.out.println(names.indexOf("张飞"));
System.out.println(names.lastIndexOf("张飞"));
5.根据元素索引位置进行的判断;
if (names.indexOf("刘备")==0) {
System.out.println("刘备在这里");
}else if (names.lastIndexOf("刘备")==3) {
System.out.println("刘备在那里");
}else {
System.out.println("刘备到底在哪里？");
}
6.利用list中索引位置重新生成一个新的list（截取集合）；
方法： .subList(fromIndex,toIndex)；.size()；该方法得到list中的元素数的和
List<String> phone=new ArrayList<>();
phone.add("三星"); //索引为0
phone.add("苹果"); //索引为1
phone.add("锤子"); //索引为2
phone.add("华为"); //索引为3
phone.add("小米"); //索引为4
//原list进行遍历
for(String pho:phone){
System.out.println(pho);
}
//生成新list
phone=phone.subList(1, 4); //.subList(fromIndex, toIndex) //利用索引1-4的对象重新生成一个list，但是不包含索引为4的元素，4-1=3
for (int i = 0; i < phone.size(); i++) { // phone.size() 该方法得到list中的元素数的和
System.out.println("新的list包含的元素是"+phone.get(i));
}
7.对比两个list中的所有元素；
//两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象
//1.<BR>if (person.equals(fruits)) {
System.out.println("两个list中的所有元素相同");
}else {
System.out.println("两个list中的所有元素不一样");
}
//2.
if (person.hashCode()==fruits.hashCode()) {
System.out.println("我们相同");
}else {
System.out.println("我们不一样");
}
8.判断list是否为空；
//空则返回true，非空则返回false
if (person.isEmpty()) {
System.out.println("空的");
}else {
System.out.println("不是空的");
}
9.返回Iterator集合对象；
System.out.println("返回Iterator集合对象:"+person.iterator());
10.将集合转换为字符串；
String liString="";
liString=person.toString();
System.out.println("将集合转换为字符串:"+liString);
11.将集合转换为数组；
System.out.println("将集合转换为数组:"+person.toArray());
12.集合类型转换；
//1.默认类型
List<Object> listsStrings=new ArrayList<>();
for (int i = 0; i < person.size(); i++) {
listsStrings.add(person.get(i));
}
//2.指定类型
List<StringBuffer> lst=new ArrayList<>();
for(String string:person){
lst.add(StringBuffer(string));
} 二：LinkedList
LinkedList通过另一种方式实现List接口，不仅如此，它还实现了 Queue、Deque接口，使得LinkedList可以作为栈、队列、双端队列来使用。
LinkedList底层是一个双向链表。其对于 List、Queue、Deque接口中的方法都是通过封装在链表上的操作来实现的。查询慢，增删快。线程不安全，效率高。
底层源码：
1 package com.chy.collection.core;
2
3 import java.util.AbstractSequentialList;
4 import java.util.Collections;
5 import java.util.ConcurrentModificationException;
6 import java.util.Deque;
7 import java.util.Iterator;
8 import java.util.NoSuchElementException;
9 import java.util.Queue;
10 import java.util.Vector;
11
12 /**
13 * LinkedList实际上是通过双向链表去实现的、整个链表是通过Entry实体类来存储数据的
14 */
15
16 public class LinkedList<E>
17 extends AbstractSequentialList<E>
18 implements List<E>, Deque<E>, Cloneable, java.io.Serializable
19 {
20 //链表的表头、表头不包含任何数据、
21 //Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。
22 private transient Entry<E> header = new Entry<E>(null, null, null);
23
24 // LinkedList中元素个数
25 private transient int size = 0;
26
27 /**
28 * 构造一个空的LinkedList、只含有表头
29 */
30 public LinkedList() {
31 header.next = header.previous = header;
32 }
33
34 /**
35 * 创建一个包含c的LinkedList、先创建默认空、然后将c中所有元素添加到LinkedList中
36 */
37 public LinkedList(Collection<? extends E> c) {
38 this();
39 addAll(c);
40 }
41
42 /** 获取链表第一个元素、*/
43 public E getFirst() {
44 if (size==0)
45 throw new NoSuchElementException();
46 //因其是双向链表、这里的header可视为顺序的第一个不含元素的表头、所以第一个是此header的下一个元素
47 return header.next.element;
48 }
49
50 /** 获取链表最后一个元素*/
51 public E getLast() {
52 if (size==0)
53 throw new NoSuchElementException();
54 //因其是双向链表、这里的header可视为逆序的第一个不含元素的表头、所以最后一个是此header的上一个元素
55 return header.previous.element;
56 }
57
58 /** 删除LinkedList的第一个元素*/
59 public E removeFirst() {
60 return remove(header.next);
61 }
62
63 /** 删除LinkedList的最后一个元素*/
64 public E removeLast() {
65 return remove(header.previous);
66 }
67
68 /** 将元素e添加到LinkedList的起始位置*/
69 public void addFirst(E e) {
70 addBefore(e, header.next);
71 }
72
73 /** 将元素e添加到LinkedList的结束位置*/
74 public void addLast(E e) {
75 addBefore(e, header);
76 }
77
78 /** 判断是否包含Object o*/
79 public boolean contains(Object o) {
80 return indexOf(o) != -1;
81 }
82
83 /** 返回LinkedList的大小*/
84 public int size() {
85 return size;
86 }
87
88 /** 将元素(E)添加到LinkedList中、添加到末尾*/
89 public boolean add(E e) {
90 addBefore(e, header);
91 return true;
92 }
93
94 /** 从LinkedList中删除o、如果存在则删除第一查找到的o并返回true、若不存在则返回false*/
95 public boolean remove(Object o) {
96 if (o==null) {
97 for (Entry<E> e = header.next; e != header; e = e.next) {
98 if (e.element==null) {
99 remove(e);
100 return true;
101 }
102 }
103 } else {
104 for (Entry<E> e = header.next; e != header; e = e.next) {
105 if (o.equals(e.element)) {
106 remove(e);
107 return true;
108 }
109 }
110 }
111 return false;
112 }
113
114 /** 将c中元素添加到双向链表LinkedList中、从尾部开始添加*/
115 public boolean addAll(Collection<? extends E> c) {
116 return addAll(size, c);
117 }
118
119 /** 将c中元素添加到双向链表LinkedList中、所有元素添加到index与index+1表示的元素中间*/
120 public boolean addAll(int index, Collection<? extends E> c) {
121 if (index < 0 || index > size)
122 throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
123 //将c转换成数组、方便遍历元素和获取元素个数
124 Object[] a = c.toArray();
125 int numNew = a.length;
126 if (numNew==0)
127 return false;
128 modCount++;
129
130 //设置当前要插入节点的下一个节点
131 Entry<E> successor = (index==size ? header : entry(index));
132 //设置当前要插入节点的上一个节点
133 Entry<E> predecessor = successor.previous;
134 //将c中元素插入到LinkedList中
135 for (int i=0; i<numNew; i++) {
136 Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
137 predecessor.next = e;
138 predecessor = e;
139 }
140 successor.previous = predecessor;
141 size += numNew;
142 return true;
143 }
144
145 /** 删除LinkedList中所有元素*/
146 public void clear() {
147 Entry<E> e = header.next;
148 while (e != header) {
149 Entry<E> next = e.next;
150 e.next = e.previous = null;
151 e.element = null;
152 e = next;
153 }
154 header.next = header.previous = header;
155 size = 0;
156 modCount++;
157 }
158
159
160 // Positional Access Operations
161
162 /** 获取index处的元素*/
163 public E get(int index) {
164 return entry(index).element;
165 }
166
167 /** 设置index处的元素、并将old元素返回*/
168 public E set(int index, E element) {
169 Entry<E> e = entry(index);
170 E oldVal = e.element;
171 e.element = element;
172 return oldVal;
173 }
174
175 /** 在index前添加节点，且节点的值为element*/
176 public void add(int index, E element) {
177 addBefore(element, (index==size ? header : entry(index)));
178 }
179
180 /** 删除index位置的节点*/
181 public E remove(int index) {
182 return remove(entry(index));
183 }
184
185 /** 获取双向链表LinkedList中指定位置的节点、是LinkedList实现List中通过index操作元素的关键*/
186 private Entry<E> entry(int index) {
187 if (index < 0 || index >= size)
188 throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
189 Entry<E> e = header;
190 if (index < (size >> 1)) {
191 for (int i = 0; i <= index; i++)
192 e = e.next;
193 } else {
194 for (int i = size; i > index; i--)
195 e = e.previous;
196 }
197 return e;
198 }
199
200
201 // Search Operations
202
203 /** 查询o所在LinkedList中的位置的索引、从前向后、不存在返回-1*/
204 public int indexOf(Object o) {
205 int index = 0;
206 if (o==null) {
207 for (Entry e = header.next; e != header; e = e.next) {
208 if (e.element==null)
209 return index;
210 index++;
211 }
212 } else {
213 for (Entry e = header.next; e != header; e = e.next) {
214 if (o.equals(e.element))
215 return index;
216 index++;
217 }
218 }
219 return -1;
220 }
221
222 /** 查询o所在LinkedList中的位置的索引、从后向前、不存在返回-1*/
223 public int lastIndexOf(Object o) {
224 int index = size;
225 if (o==null) {
226 for (Entry e = header.previous; e != header; e = e.previous) {
227 index--;
228 if (e.element==null)
229 return index;
230 }
231 } else {
232 for (Entry e = header.previous; e != header; e = e.previous) {
233 index--;
234 if (o.equals(e.element))
235 return index;
236 }
237 }
238 return -1;
239 }
240
241 // Queue operations.
242
243 /** 返回第一个节点、若size为0则返回null*/
244 public E peek() {
245 if (size==0)
246 return null;
247 return getFirst();
248 }
249
250 /** 返回第一个节点、若size为0则抛异常NoSuchElementException*/
251 public E element() {
252 return getFirst();
253 }
254
255 /** 删除并返回第一个节点 、若LinkedList的大小为0,则返回null*/
256 public E poll() {
257 if (size==0)
258 return null;
259 return removeFirst();
260 }
261
262 /** 删除第一个元素、若LinkedList的大小为0,则抛异常*/
263 public E remove() {
264 return removeFirst();
265 }
266
267 /** 将e添加双向链表末尾*/
268 public boolean offer(E e) {
269 return add(e);
270 }
271
272 // Deque operations
273 /** 将e添加双向链表开头*/
274 public boolean offerFirst(E e) {
275 addFirst(e);
276 return true;
277 }
278
279 /** 将e添加双向链表末尾*/
280 public boolean offerLast(E e) {
281 addLast(e);
282 return true;
283 }
284
285 /**返回第一个节点、若LinkedList的大小为0,则返回null*/
286 public E peekFirst() {
287 if (size==0)
288 return null;
289 return getFirst();
290 }
291
292 /**返回最后一个节点、 若LinkedList的大小为0,则返回null*/
293 public E peekLast() {
294 if (size==0)
295 return null;
296 return getLast();
297 }
298
299 /** 删除并返回第一个、若LinkedList的大小为0,则返回null*/
300 public E pollFirst() {
301 if (size==0)
302 return null;
303 return removeFirst();
304 }
305
306 /** 删除并返回最后一个、若LinkedList的大小为0,则返回null*/
307 public E pollLast() {
308 if (size==0)
309 return null;
310 return removeLast();
311 }
312
313 /** 将e插入到双向链表开头*/
314 public void push(E e) {
315 addFirst(e);
316 }
317
318 /** 删除并返回第一个节点*/
319 public E pop() {
320 return removeFirst();
321 }
322
323 /** 从LinkedList中删除o、如果存在则删除第一查找到的o并返回true、若不存在则返回false*/
324 public boolean removeFirstOccurrence(Object o) {
325 return remove(o);
326 }
327
328 /** 从LinkedList末尾向前查找，删除第一个值为元素(o)的节点*/
329 public boolean removeLastOccurrence(Object o) {
330 if (o==null) {
331 for (Entry<E> e = header.previous; e != header; e = e.previous) {
332 if (e.element==null) {
333 remove(e);
334 return true;
335 }
336 }
337 } else {
338 for (Entry<E> e = header.previous; e != header; e = e.previous) {
339 if (o.equals(e.element)) {
340 remove(e);
341 return true;
342 }
343 }
344 }
345 return false;
346 }
347
348 /** 返回“index到末尾的全部节点”对应的ListIterator对象(List迭代器)*/
349 public ListIterator<E> listIterator(int index) {
350 return new ListItr(index);
351 }
352
353 private class ListItr implements ListIterator<E> {
354 // 上一次返回的节点
355 private Entry<E> lastReturned = header;
356 // 下一个节点
357 private Entry<E> next;
358 // 下一个节点对应的索引值
359 private int nextIndex;
360 // 期望的改变计数。用来实现fail-fast机制。
361 private int expectedModCount = modCount;
362
363 //构造函数、 从index位置开始进行迭代
364 ListItr(int index) {
365 if (index < 0 || index > size)
366 throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
367 /*
368 * 若 “index 小于 ‘双向链表长度的一半’”，则从第一个元素开始往后查找；
369 * 否则，从最后一个元素往前查找。
370 */
371 if (index < (size >> 1)) {
372 next = header.next;
373 for (nextIndex=0; nextIndex<index; nextIndex++)
374 next = next.next;
375 } else {
376 next = header;
377 for (nextIndex=size; nextIndex>index; nextIndex--)
378 next = next.previous;
379 }
380 }
381 // 是否存在下一个元素
382 public boolean hasNext() {
383 return nextIndex != size;
384 }
385 // 获取下一个元素
386 public E next() {
387 checkForComodification();
388 if (nextIndex == size)
389 throw new NoSuchElementException();
390
391 lastReturned = next;
392 next = next.next;
393 nextIndex++;
394 return lastReturned.element;
395 }
396
397 // 是否存在上一个元素
398 public boolean hasPrevious() {
399 return nextIndex != 0;
400 }
401 // 获取上一个元素
402 public E previous() {
403 if (nextIndex == 0)
404 throw new NoSuchElementException();
405
406 lastReturned = next = next.previous;
407 nextIndex--;
408 checkForComodification();
409 return lastReturned.element;
410 }
411
412 // 获取下一个元素的索引
413 public int nextIndex() {
414 return nextIndex;
415 }
416
417 // 获取上一个元素的索引
418 public int previousIndex() {
419 return nextIndex-1;
420 }
421 // 删除双向链表中的当前节点
422 public void remove() {
423 checkForComodification();
424 Entry<E> lastNext = lastReturned.next;
425 try {
426 LinkedList.this.remove(lastReturned);
427 } catch (NoSuchElementException e) {
428 throw new IllegalStateException();
429 }
430 if (next==lastReturned)
431 next = lastNext;
432 else
433 nextIndex--;
434 lastReturned = header;
435 expectedModCount++;
436 }
437 // 设置当前节点为e
438 public void set(E e) {
439 if (lastReturned == header)
440 throw new IllegalStateException();
441 checkForComodification();
442 lastReturned.element = e;
443 }
444 // 将e添加到当前节点的前面
445 public void add(E e) {
446 checkForComodification();
447 lastReturned = header;
448 addBefore(e, next);
449 nextIndex++;
450 expectedModCount++;
451 }
452 // 判断 “modCount和expectedModCount是否相等”，以此来实现fail-fast机制。
453 final void checkForComodification() {
454 if (modCount != expectedModCount)
455 throw new ConcurrentModificationException();
456 }
457 }
458
459 /**
460 * 内部静态类、是双向链表的节点所对应的数据结构、
461 * 此数据结构包含三部分：上一节点、下一节点、当前节点值
462 */
463 private static class Entry<E> {
464 //当前节点值
465 E element;
466 //下一节点
467 Entry<E> next;
468 //上一节点
469 Entry<E> previous;
470
471 /**
472 * 链表节点构造函数
473 * @param element 节点值
474 * @param next 下一节点
475 * @param previous 上一节点
476 */
477 Entry(E element, Entry<E> next, Entry<E> previous) {
478 this.element = element;
479 this.next = next;
480 this.previous = previous;
481 }
482 }
483
484 //新建节点、节点值是e、将新建的节点添加到entry之前
485 private Entry<E> addBefore(E e, Entry<E> entry) {
486 //觉得难理解的可以先花个几分钟看一下链式结构资料、最好是图片形式的
487 //新建节点实体
488 Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
489 //将参照节点原来的上一个节点（即插在谁前面的）的下一个节点设置成newEntry
490 newEntry.previous.next = newEntry;
491 //将参照节点（即插在谁前面的）的前一个节点设置成newEntry
492 newEntry.next.previous = newEntry;
493 size++;
494 modCount++;
495 return newEntry;
496 }
497
498
499 //将节点从链表中删除、返回被删除的节点的内容
500 private E remove(Entry<E> e) {
501 //如果是表头、抛异常
502 if (e == header)
503 throw new NoSuchElementException();
504
505 E result = e.element;
506 //下面实际上就是、将e拿掉、然后将e的上下两个节点连接起来
507 e.previous.next = e.next;
508 e.next.previous = e.previous;
509 e.next = e.previous = null;
510 e.element = null;
511 size--;
512 modCount++;
513 return result;
514 }
515
516 /**
517 * 反向迭代器
518 * @since 1.6
519 */
520 public Iterator<E> descendingIterator() {
521 return new DescendingIterator();
522 }
523
524 /** 反向迭代器实现类 */
525 private class DescendingIterator implements Iterator {
526 final ListItr itr = new ListItr(size());
527 public boolean hasNext() {
528 return itr.hasPrevious();
529 }
530 public E next() {
531 return itr.previous();
532 }
533 public void remove() {
534 itr.remove();
535 }
536 }
537
538 /** 返回LinkedList的克隆对象*/
539 public Object clone() {
540 LinkedList<E> clone = null;
541 try {
542 clone = (LinkedList<E>) super.clone();
543 } catch (CloneNotSupportedException e) {
544 throw new InternalError();
545 }
546
547 // Put clone into "virgin" state
548 clone.header = new Entry<E>(null, null, null);
549 clone.header.next = clone.header.previous = clone.header;
550 clone.size = 0;
551 clone.modCount = 0;
552
553 // Initialize clone with our elements
554 for (Entry<E> e = header.next; e != header; e = e.next)
555 clone.add(e.element);
556
557 return clone;
558 }
559
560 /** 将LinkedList中的所有元素转换成Object[]中*/
561 public Object[] toArray() {
562 Object[] result = new Object[size];
563 int i = 0;
564 for (Entry<E> e = header.next; e != header; e = e.next)
565 result[i++] = e.element;
566 return result;
567 }
568
569 /** 将LinkedList中的所有元素转换成Object[]中、并且完成类型转换*/
570 public <T> T[] toArray(T[] a) {
571 if (a.length < size)
572 a = (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
573 int i = 0;
574 Object[] result = a;
575 for (Entry<E> e = header.next; e != header; e = e.next)
576 result[i++] = e.element;
577
578 if (a.length > size)
579 a[size] = null;
580
581 return a;
582 }
583
584 private static final long serialVersionUID = 876323262645176354L;
585
586 /** 将LinkedList的“容量，所有的元素值”都写入到输出流中
587 * 1、将LinkedList的容量写入进去
588 * 2、将LinkedList中的所有元素写入进去
589 */
590 private void writeObject(java.io.ObjectOutputStream s)
591 throws java.io.IOException {
592 // Write out any hidden serialization magic
593 s.defaultWriteObject();
594
595 // Write out size
596 s.writeInt(size);
597
598 // Write out all elements in the proper order.
599 for (Entry e = header.next; e != header; e = e.next)
600 s.writeObject(e.element);
601 }
602
603 /**
604 * 将写入的LinkedList读取出来
605 * 1、读取写入的LinkedList的容量
606 * 2、读取写入的元素
607 */
608 private void readObject(java.io.ObjectInputStream s)
609 throws java.io.IOException, ClassNotFoundException {
610 // Read in any hidden serialization magic
611 s.defaultReadObject();
612
613 // Read in size
614 int size = s.readInt();
615
616 // Initialize header
617 header = new Entry<E>(null, null, null);
618 header.next = header.previous = header;
619
620 // Read in all elements in the proper order.
621 for (int i=0; i<size; i++)
622 addBefore((E)s.readObject(), header);
623 }
624 }三：Vector
Vector也是在底层通过一个数组来保存数据，通过底层数组的一系列操作来实现List接口。同ArrayList一样，Vector底层数组容量不足时会扩容，然后把原有内容复制过去。底层数据结构是数组，查询快，增删慢。线程不安全，效率高。线程安全，效率低。
底层源码：
1 package java.util;
2 public class Vector<E>
3 extends AbstractList<E>
4 implements List<E>, RandomAccess, Cloneable, java.io.Serializable
5 {
6
7 // 保存Vector中数据的数组
8 protected Object[] elementData;
9 // 实际数据的数量
10 protected int elementCount;
11 // 容量增长系数
12 protected int capacityIncrement;
13 // Vector的序列版本号
14 private static final long serialVersionUID = -2767605614048989439L;
15 // Vector构造函数。默认容量是10。
16 public Vector() {
17 this(10);
18 }
19 // 指定Vector容量大小的构造函数
20 public Vector(int initialCapacity) {
21 this(initialCapacity, 0);
22 }
23 // 指定Vector"容量大小"和"增长系数"的构造函数
24 public Vector(int initialCapacity, int capacityIncrement) {
25 super();
26 if (initialCapacity < 0)
27 throw new IllegalArgumentException("Illegal Capacity: "+
28 initialCapacity);
29 // 新建一个数组，数组容量是initialCapacity
30 this.elementData = new Object[initialCapacity];
31 // 设置容量增长系数
32 this.capacityIncrement = capacityIncrement;
33 }
34 // 指定集合的Vector构造函数。
35 public Vector(Collection<? extends E> c) {
36 // 获取“集合(c)”的数组，并将其赋值给elementData
37 elementData = c.toArray();
38 // 设置数组长度
39 elementCount = elementData.length;
40 // c.toArray might (incorrectly) not return Object[] (see 6260652)
41 if (elementData.getClass() != Object[].class)
42 elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
43 }
44 // 将数组Vector的全部元素都拷贝到数组anArray中
45 public synchronized void copyInto(Object[] anArray) {
46 System.arraycopy(elementData, 0, anArray, 0, elementCount);
47 }
48 // 将当前容量值设为 =实际元素个数
49 public synchronized void trimToSize() {
50 modCount++;
51 int oldCapacity = elementData.length;
52 if (elementCount < oldCapacity) {
53 elementData = Arrays.copyOf(elementData, elementCount);
54 }
55 }
56 // 确认“Vector容量”的帮助函数
57 private void ensureCapacityHelper(int minCapacity) {
58 int oldCapacity = elementData.length;
59 // 当Vector的容量不足以容纳当前的全部元素，增加容量大小。
60 // 若 容量增量系数>0(即capacityIncrement>0)，则将容量增大当capacityIncrement
61 // 否则，将容量增大一倍。
62 if (minCapacity > oldCapacity) {
63 Object[] oldData = elementData;
64 int newCapacity = (capacityIncrement > 0) ?
65 (oldCapacity + capacityIncrement) : (oldCapacity * 2);
66 if (newCapacity < minCapacity) {
67 newCapacity = minCapacity;
68 }
69 elementData = Arrays.copyOf(elementData, newCapacity);
70 }
71 }
72 // 确定Vector的容量。
73 public synchronized void ensureCapacity(int minCapacity) {
74 // 将Vector的改变统计数+1
75 modCount++;
76 ensureCapacityHelper(minCapacity);
77 }
78 // 设置容量值为 newSize
79 public synchronized void setSize(int newSize) {
80 modCount++;
81 if (newSize > elementCount) {
82 // 若 "newSize 大于 Vector容量"，则调整Vector的大小。
83 ensureCapacityHelper(newSize);
84 } else {
85 // 若 "newSize 小于/等于 Vector容量"，则将newSize位置开始的元素都设置为null
86 for (int i = newSize ; i < elementCount ; i++) {
87 elementData[i] = null;
88 }
89 }
90 elementCount = newSize;
91 }
92 // 返回“Vector的总的容量”
93 public synchronized int capacity() {
94 return elementData.length;
95 }
96 // 返回“Vector的实际大小”，即Vector中元素个数
97 public synchronized int size() {
98 return elementCount;
99 }
100 // 判断Vector是否为空
101 public synchronized boolean isEmpty() {
102 return elementCount == 0;
103 }
104 // 返回“Vector中全部元素对应的Enumeration”
105 public Enumeration<E> elements() {
106 // 通过匿名类实现Enumeration
107 return new Enumeration<E>() {
108 int count = 0;
109 // 是否存在下一个元素
110 public boolean hasMoreElements() {
111 return count < elementCount;
112 }
113 // 获取下一个元素
114 public E nextElement() {
115 synchronized (Vector.this) {
116 if (count < elementCount) {
117 return (E)elementData[count++];
118 }
119 }
120 throw new NoSuchElementException("Vector Enumeration");
121 }
122 };
123 }
124 // 返回Vector中是否包含对象(o)
125 public boolean contains(Object o) {
126 return indexOf(o, 0) >= 0;
127 }
128
129 // 从index位置开始向后查找元素(o)。
130 // 若找到，则返回元素的索引值；否则，返回-1
131 public synchronized int indexOf(Object o, int index) {
132 if (o == null) {
133 // 若查找元素为null，则正向找出null元素，并返回它对应的序号
134 for (int i = index ; i < elementCount ; i++)
135 if (elementData[i]==null)
136 return i;
137 } else {
138 // 若查找元素不为null，则正向找出该元素，并返回它对应的序号
139 for (int i = index ; i < elementCount ; i++)
140 if (o.equals(elementData[i]))
141 return i;
142 }
143 return -1;
144 }
145 // 查找并返回元素(o)在Vector中的索引值
146 public int indexOf(Object o) {
147 return indexOf(o, 0);
148 }
149 // 从后向前查找元素(o)。并返回元素的索引
150 public synchronized int lastIndexOf(Object o) {
151 return lastIndexOf(o, elementCount-1);
152 }
153 // 从后向前查找元素(o)。开始位置是从前向后的第index个数；
154 // 若找到，则返回元素的“索引值”；否则，返回-1。
155 public synchronized int lastIndexOf(Object o, int index) {
156 if (index >= elementCount)
157 throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
158 if (o == null) {
159 // 若查找元素为null，则反向找出null元素，并返回它对应的序号
160 for (int i = index; i >= 0; i--)
161 if (elementData[i]==null)
162 return i;
163 } else {
164 // 若查找元素不为null，则反向找出该元素，并返回它对应的序号
165 for (int i = index; i >= 0; i--)
166 if (o.equals(elementData[i]))
167 return i;
168 }
169 return -1;
170 }
171 // 返回Vector中index位置的元素。
172 // 若index月结，则抛出异常
173 public synchronized E elementAt(int index) {
174 if (index >= elementCount) {
175 throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
176 }
177 return (E)elementData[index];
178 }
179 // 获取Vector中的第一个元素。
180 // 若失败，则抛出异常！
181 public synchronized E firstElement() {
182 if (elementCount == 0) {
183 throw new NoSuchElementException();
184 }
185 return (E)elementData[0];
186 }
187 // 获取Vector中的最后一个元素。
188 // 若失败，则抛出异常！
189 public synchronized E lastElement() {
190 if (elementCount == 0) {
191 throw new NoSuchElementException();
192 }
193 return (E)elementData[elementCount - 1];
194 }
195 // 设置index位置的元素值为obj
196 public synchronized void setElementAt(E obj, int index) {
197 if (index >= elementCount) {
198 throw new ArrayIndexOutOfBoundsException(index + " >= " +
199 elementCount);
200 }
201 elementData[index] = obj;
202 }
203 // 删除index位置的元素
204 public synchronized void removeElementAt(int index) {
205 modCount++;
206 if (index >= elementCount) {
207 throw new ArrayIndexOutOfBoundsException(index + " >= " +
208 elementCount);
209 } else if (index < 0) {
210 throw new ArrayIndexOutOfBoundsException(index);
211 }
212 int j = elementCount - index - 1;
213 if (j > 0) {
214 System.arraycopy(elementData, index + 1, elementData, index, j);
215 }
216 elementCount--;
217 elementData[elementCount] = null; /* to let gc do its work */
218 }
219 // 在index位置处插入元素(obj)
220 public synchronized void insertElementAt(E obj, int index) {
221 modCount++;
222 if (index > elementCount) {
223 throw new ArrayIndexOutOfBoundsException(index
224 + " > " + elementCount);
225 }
226 ensureCapacityHelper(elementCount + 1);
227 System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
228 elementData[index] = obj;
229 elementCount++;
230 }
231 // 将“元素obj”添加到Vector末尾
232 public synchronized void addElement(E obj) {
233 modCount++;
234 ensureCapacityHelper(elementCount + 1);
235 elementData[elementCount++] = obj;
236 }
237 // 在Vector中查找并删除元素obj。
238 // 成功的话，返回true；否则，返回false。
239 public synchronized boolean removeElement(Object obj) {
240 modCount++;
241 int i = indexOf(obj);
242 if (i >= 0) {
243 removeElementAt(i);
244 return true;
245 }
246 return false;
247 }
248 // 删除Vector中的全部元素
249 public synchronized void removeAllElements() {
250 modCount++;
251 // 将Vector中的全部元素设为null
252 for (int i = 0; i < elementCount; i++)
253 elementData[i] = null;
254 elementCount = 0;
255 }
256 // 克隆函数
257 public synchronized Object clone() {
258 try {
259 Vector<E> v = (Vector<E>) super.clone();
260 // 将当前Vector的全部元素拷贝到v中
261 v.elementData = Arrays.copyOf(elementData, elementCount);
262 v.modCount = 0;
263 return v;
264 } catch (CloneNotSupportedException e) {
265 // this shouldn't happen, since we are Cloneable
266 throw new InternalError();
267 }
268 }
269 // 返回Object数组
270 public synchronized Object[] toArray() {
271 return Arrays.copyOf(elementData, elementCount);
272 }
273 // 返回Vector的模板数组。所谓模板数组，即可以将T设为任意的数据类型
274 public synchronized <T> T[] toArray(T[] a) {
275 // 若数组a的大小 < Vector的元素个数；
276 // 则新建一个T[]数组，数组大小是“Vector的元素个数”，并将“Vector”全部拷贝到新数组中
277 if (a.length < elementCount)
278 return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());
279 // 若数组a的大小 >= Vector的元素个数；
280 // 则将Vector的全部元素都拷贝到数组a中。
281 System.arraycopy(elementData, 0, a, 0, elementCount);
282 if (a.length > elementCount)
283 a[elementCount] = null;
284 return a;
285 }
286 // 获取index位置的元素
287 public synchronized E get(int index) {
288 if (index >= elementCount)
289 throw new ArrayIndexOutOfBoundsException(index);
290 return (E)elementData[index];
291 }
292 // 设置index位置的值为element。并返回index位置的原始值
293 public synchronized E set(int index, E element) {
294 if (index >= elementCount)
295 throw new ArrayIndexOutOfBoundsException(index);
296 Object oldValue = elementData[index];
297 elementData[index] = element;
298 return (E)oldValue;
299 }
300 // 将“元素e”添加到Vector最后。
301 public synchronized boolean add(E e) {
302 modCount++;
303 ensureCapacityHelper(elementCount + 1);
304 elementData[elementCount++] = e;
305 return true;
306 }
307 // 删除Vector中的元素o
308 public boolean remove(Object o) {
309 return removeElement(o);
310 }
311 // 在index位置添加元素element
312 public void add(int index, E element) {
313 insertElementAt(element, index);
314 }
315 // 删除index位置的元素，并返回index位置的原始值
316 public synchronized E remove(int index) {
317 modCount++;
318 if (index >= elementCount)
319 throw new ArrayIndexOutOfBoundsException(index);
320 Object oldValue = elementData[index];
321 int numMoved = elementCount - index - 1;
322 if (numMoved > 0)
323 System.arraycopy(elementData, index+1, elementData, index,
324 numMoved);
325 elementData[--elementCount] = null; // Let gc do its work
326 return (E)oldValue;
327 }
328 // 清空Vector
329 public void clear() {
330 removeAllElements();
331 }
332 // 返回Vector是否包含集合c
333 public synchronized boolean containsAll(Collection<?> c) {
334 return super.containsAll(c);
335 }
336 // 将集合c添加到Vector中
337 public synchronized boolean addAll(Collection<? extends E> c) {
338 modCount++;
339 Object[] a = c.toArray();
340 int numNew = a.length;
341 ensureCapacityHelper(elementCount + numNew);
342 // 将集合c的全部元素拷贝到数组elementData中
343 System.arraycopy(a, 0, elementData, elementCount, numNew);
344 elementCount += numNew;
345 return numNew != 0;
346 }
347 // 删除集合c的全部元素
348 public synchronized boolean removeAll(Collection<?> c) {
349 return super.removeAll(c);
350 }
351 // 删除“非集合c中的元素”
352 public synchronized boolean retainAll(Collection<?> c) {
353 return super.retainAll(c);
354 }
355 // 从index位置开始，将集合c添加到Vector中
356 public synchronized boolean addAll(int index, Collection<? extends E> c) {
357 modCount++;
358 if (index < 0 || index > elementCount)
359 throw new ArrayIndexOutOfBoundsException(index);
360 Object[] a = c.toArray();
361 int numNew = a.length;
362 ensureCapacityHelper(elementCount + numNew);
363 int numMoved = elementCount - index;
364 if (numMoved > 0)
365 System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
366 System.arraycopy(a, 0, elementData, index, numNew);
367 elementCount += numNew;
368 return numNew != 0;
369 }
370 // 返回两个对象是否相等
371 public synchronized boolean equals(Object o) {
372 return super.equals(o);
373 }
374 // 计算哈希值
375 public synchronized int hashCode() {
376 return super.hashCode();
377 }
378 // 调用父类的toString()
379 public synchronized String toString() {
380 return super.toString();
381 }
382 // 获取Vector中fromIndex(包括)到toIndex(不包括)的子集
383 public synchronized List<E> subList(int fromIndex, int toIndex) {
384 return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);
385 }
386 // 删除Vector中fromIndex到toIndex的元素
387 protected synchronized void removeRange(int fromIndex, int toIndex) {
388 modCount++;
389 int numMoved = elementCount - toIndex;
390 System.arraycopy(elementData, toIndex, elementData, fromIndex,
391 numMoved);
392 // Let gc do its work
393 int newElementCount = elementCount - (toIndex-fromIndex);
394 while (elementCount != newElementCount)
395 elementData[--elementCount] = null;
396 }
397 // java.io.Serializable的写入函数
398 private synchronized void writeObject(java.io.ObjectOutputStream s)
399 throws java.io.IOException {
400 s.defaultWriteObject();
401 }
402 }来源：oschina
链接：https://my.oschina.net/u/4382392/blog/3920756