区别：
1）Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
2）当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。
3）对于Vector、是一个比较古老的类、相对于ArrayList而言、它通过将许多方法使用synchronized修饰来保证线程安全性、但是保证线程安全是要代价的、这也使得他的效率并没有ArrayList高
arraylist的特点：
1、ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
2、ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
3、ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
4、ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
5、ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
vector的特点：
1、Vector是内部是以动态数组的形式来存储数据的。
2、Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较地下、具体原因后面有分析。
3、Vector实现了AbstractList抽象类、List接口、所以其更具有了AbstractList和List的功能、前面我们知道AbstractList内部已经实现了获取Iterator和ListIterator的方法、所以Vector只需关心对数组操作的方法的实现、
4、Vector实现了RandomAccess接口、此接口只有声明、没有方法体、表示Vector支持随机访问。
5、Vector实现了Cloneable接口、此接口只有声明、没有方法体、表示Vector支持克隆。
6、Vector实现了Serializable接口、此接口只有声明、没有方法体、表示Vector支持序列化、即可以将Vector以流的形式通过ObjectOutputStream来写入到流中。
1 //底层的arraylist实现了AbstractList类 和四个接口
2 //list接口、随机访问接口、可克隆接口、序列化接口
3 public class MyArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
4
5 private static final long serialVersionUID = 1L;
6 // 属性,元素数据
7 // transient：反序列化的关键字，不可以被serialized的数组
8 private transient Object[] elementData;
9 // 数组的大小,即包含的元素的个数
10 private int size;
11
12 // 构造函数1：根据初始大小分配数组
13 public MyArrayList(int initialCapacity) {
14 super();
15 if (initialCapacity < 0) {
16 System.out.println("初始化失败" + initialCapacity);
17 }
18 // 否则按照initialCapacity分配大小
19 this.elementData = new Object[initialCapacity];
20 }
21
22 // 构造函数2：以10为大小分配数组
23 public MyArrayList() {
24 this(10);
25 }
26
27 // 构造函数3：参数为集合collection,集合之间的拷贝
28 // Collection<? extends E>代表Collection<E>的子类
29 public MyArrayList(Collection<? extends E> c) {
30 // 把集合中的元素赋值给属性集合
31 elementData = c.toArray();
32 // 得到集合的大小
33 size = elementData.length;
34 // c返回的如果不是object[]数组，则显式转换
35 if (elementData.getClass() != Object[].class) {
36 elementData = Arrays.copyOf(elementData, size, Object[].class);
37 }
38 }
39
40 // 保证数组的容量，确保不会越界
41 public void ensureCapacity(int minCapacity) {
42 // 该变量来自AbstractList，表示被修改的次数
43 modCount++;
44 // 原来数组的容量
45 int oldCapacity = elementData.length;
46 // 如果新的容量更大，则需要重新分配
47 if (minCapacity > oldCapacity) {
48 // 赋值出新的数组
49 Object oldData[] = elementData;
50 // 构造出新的数组容量，增加原有容量的50%
51 int newCapacity = (oldCapacity * 3) / 2 + 1;
52 // 如果新构造出的容量比参数minCapacity要小，则赋值大小和数组本身
53 if (newCapacity < minCapacity) {
54 newCapacity = minCapacity;
55 elementData = Arrays.copyOf(elementData, newCapacity);
56 }
57 } // end of if
58 // 当然，如果新的容量比老的容量小，则上面的if判断不会执行。
59 }
60
61 // 在尾部添加一个元素
62 public boolean add(E e) {
63 // 保证容量
64 ensureCapacity(size + 1);
65 // 赋值新的元素
66 elementData[size++] = e;
67 return true;
68 }
69
70 // 在指定位置处插入元素
71 public void add(int index, E element) {
72 if (index > size || index < 0) {
73 System.out.println("数组越界");
74 }
75 // 调整容量
76 ensureCapacity(size + 1);
77 // 元素拷贝
78 /*
79 * 将elementData从index开始的元素赋值到index+1,复制的大小为size-index.也即将index后的元素整体后移动
80 */
81 System.arraycopy(elementData, index, elementData, index + 1, size - index);
82 // 将element指向到index处
83 elementData[index] = element;
84 size++;
85 }
86
87 // 将一个集合中的所有元素拷贝到elementData中
88 public boolean addAll(Collection<? extends E> c) {
89 // 将集合c转换成Object类型的数组
90 Object[] a = c.toArray();
91 // 得到数组的长度
92 int numNew = a.length;
93 // 调整容量
94 ensureCapacity(size + numNew);
95 // 数组拷贝
96 System.arraycopy(a, 0, elementData, size, numNew);
97 // 原有大小增加
98 size += numNew;
99 return numNew != 0;
100 }
101
102 // 在指定的位置，将一个集合中的元素拷贝到另外一个集合
103 public boolean addAll(int index, Collection<? extends E> c) {
104 if (index < 0 || index > size) {
105 System.out.println("数组越界");
106 }
107
108 Object[] a = c.toArray();
109 int newNum = a.length;
110 ensureCapacity(size + newNum);
111
112 // 原有数据向后移动多少呢？
113 int movedNum = size - index;
114 if (movedNum > 0) {
115 System.arraycopy(elementData, index, elementData, index + newNum, movedNum);
116 }
117 System.arraycopy(a, 0, elementData, index, newNum);
118 size += newNum;
119 return newNum != 0;
120 }
121
122 // 清空数组的内容,元素置Null 大小清0
123 public void clear() {
124 modCount++;
125 for (int i = 0; i < size; i++) {
126 elementData[i] = null;
127 }
128 size = 0;
129 }
130
131 // 浅拷贝
132 public Object clone() {
133 try {
134 MyArrayList<E> v = (MyArrayList<E>) super.clone();
135 v.elementData = Arrays.copyOf(elementData, size);
136 v.modCount = 0;
137 return v;
138 } catch (CloneNotSupportedException e) {
139 // TODO Auto-generated catch block
140 throw new InternalError();
141 }
142 }
143
144 // 返回对象在arraylist中的索引
145 public int indexOf(Object o) {
146 // 如果对象为null
147 if (o == null) {
148 for (int i = 0; i < size; i++) {
149 if (elementData[i] == null) {
150 return i;
151 }
152 }
153 } else {
154 for (int i = 0; i < size; i++) {
155 if (o.equals((elementData)[i])) {
156 return i;
157 }
158 }
159 }
160 return -1;
161 }
162
163 // 是否包含一个对象
164 public boolean contains(Object o) {
165 return indexOf(o) >= 0;
166 }
167
168 // 返回出现对象的最后一次索引
169 // 从后向前遍历arraylist
170 public int lastIndexOf(Object o) {
171 if (o == null) {
172 for (int i = size - 1; i >= 0; i--) {
173 if (elementData[i] == null) {
174 return i;
175 }
176 }
177 } else {
178 for (int i = size - 1; i >= 0; i--) {
179 if (o.equals(elementData[i])) {
180 return i;
181 }
182 }
183 }
184 return -1;
185 }
186
187 // 取得指定索引处的元素值
188 public E get(int index) {
189 RangeCheck(index);
190 return (E) elementData[index];
191 }
192
193 // 越界检查的方法
194 public void RangeCheck(int index) {
195 if (index >= size || index < 0) {
196 System.out.println("取值非法！");
197 }
198 }
199
200 // 删除指定位置处的元素，并返回该元素
201 public E remove(int index) {
202 // 边界检查
203 RangeCheck(index);
204 modCount++;
205 // 取得旧的元素
206 E oldelement = (E) elementData[index];
207 int numMoved = size - index - 1;
208 if (numMoved > 0) {
209 System.arraycopy(elementData, index + 1, elementData, index, numMoved);
210 }
211 elementData[--size] = null;
212 return oldelement;
213 }
214
215 // 判断移除是否成功
216 public boolean remove(Object o) {
217 if (o == null) {
218 for (int index = 0; index < size; index++)
219 if (elementData[index] == null) {
220 fastRemove(index);
221 return true;
222 }
223 } else {
224 for (int index = 0; index < size; index++)
225 if (o.equals(elementData[index])) {
226 fastRemove(index);
227 return true;
228 }
229 }
230 return false;
231 }
232
233 //快速移除的方法
234 private void fastRemove(int index) {
235 modCount++;
236 int numMoved = size - index - 1;
237 if (numMoved > 0)
238 System.arraycopy(elementData, index+1, elementData, index,
239 numMoved);
240 elementData[--size] = null; // Let gc do its work
241 }
242
243
244 //转换成对象数组
245 public Object[] toArray(){
246 return Arrays.copyOf(elementData,size);
247 }
248
249 //调整数组的大小
250 public void trimToSize(){
251 modCount++;
252 int oldCapacity = elementData.length;
253 if(size<oldCapacity){
254 //按照size的大小拷贝出一个数组，较少空间的使用
255 elementData=Arrays.copyOf(elementData,size);
256 }
257 }
258
259 @Override
260 public int size() {
261 // TODO Auto-generated method stub
262 return 0;
263 }
264 }
时间： 2024-08-06 15:51:31