创建一个自己的MyArrayList类，实现ArrayList的部分功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//获取长度
int getSize();
//获取容量
int getCapacity();
//判断是否为空的方法
boolean isEmpty();
//添加元素的方法
void add(E data);
void add(int index,E data);
//删除元素的方法
E delete(int index);
E deleteFirst();
E deleteLast();
//获取元素下标的方法
int indexOf(E data);
//获取元素的方法
E get(int index);
//判断是否包含元素的方法
boolean contains(E data);
//修改元素的方法，返回原位置的元素
E set(int index , E data);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public interface MyCollection<E> {
//获取长度
int getSize();
//获取容量
int getCapacity();
//判断是否为空的方法
boolean isEmpty();
//添加元素的方法
void add(E data);
void add(int index,E data);
//删除元素的方法
E delete(int index);
E deleteFirst();
E deleteLast();
//获取元素下标的方法
int indexOf(E data);
//获取元素的方法
E get(int index);
//判断是否包含元素的方法
boolean contains(E data);
//修改元素的方法，返回原位置的元素
E set(int index , E data);
}

1
2
3
4
5
6
7
public interface MyIterator<E> {
//判断是否有下一个元素
boolean hasNext();
//获取下一个元素
E next();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
public class MyArrayList<E> implements MyCollection<E>,MyIterator<E> {
private E[] datas;//存储数据数组
private MyIterator<E> iterator;//迭代器
private int size = 0;//元素个数
private int capacity = 0;//容量
//构造函数
public MyArrayList(E[] datas) {
super();
this.datas = datas;
this.size = datas.length;
}
public MyArrayList() {
this(10);
}
public MyArrayList(int capacity) {
this.datas = (E[]) new Object[capacity];
this.size = 0;
}
//iterator的相关API
public MyIterator iterator() {
this.iterator = new MyListIterator();
return this.iterator;
}
/**
* 判断是否有下一个元素的方法
*/
@Override
public boolean hasNext() {
return this.iterator.hasNext();
}
/**
* 获取下一个元素的方法
*/
@Override
public E next() {
return this.iterator.next();
}
//list的相关API
/**
* 获取元素个数的方法
*/
@Override
public int getSize() {
return this.size;
}
/**
* 获取容量的方法
*/
@Override
public int getCapacity() {
return this.capacity;
}
/**
* 判断是否为空的方法
*/
@Override
public boolean isEmpty() {
return this.size == 0;
}
/**
*添加元素的方法
*/
@Override
public void add(E data) {
this.add(size, data);
}
/**
* 添加元素的方法
*/
@Override
public void add(int index, E data) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("你添加了一个错误的参数，取值范围在0-"+size+"之间，谢谢");
}
if (size == datas.length) {
resize(datas.length*2);
}
for (int i = size-1; i >= index; i--) {
datas[i+1] = datas[i];
}
datas[index] = data;
size++;
}
/**
* 重置容量的方法
* @param i
*/
private void resize(int i) {
E[] newdatas = (E[]) new Object[capacity];
for (int j = 0; j < size; j++) {
newdatas[i] = datas[i];
}
datas = newdatas;
}
/**
* 删除元素的方法
*/
@Override
public E delete(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("你添加了一个错误的参数，取值范围在0-"+size+"之间，谢谢");
}
E result = datas[index];
int i = 0;
for (i = index; i < size; i++) {
datas[i] = datas[i+1];
}
this.size = i - 1;
return result;
}
/**
* 删除元素的方法
*/
@Override
public E deleteFirst() {
return this.delete(0);
}
/**
* 删除元素的方法
*/
@Override
public E deleteLast() {
return this.delete(size-1);
}
/**
* 查找元素的方法
*/
@Override
public int indexOf(E data) {
for (int i = 0; i < size; i++) {
if (datas[i] == data) {
return i;
}
}
return -1;
}
/**
* 获取元素的方法
*/
@Override
public E get(int index) {
if (index > 0 || index >= size) {
throw new IllegalArgumentException("你添加了一个错误的参数，取值范围在0-"+size+"之间，谢谢");
}
return datas[index];
}
/**
* 判断是否包含元素的方法
*/
@Override
public boolean contains(E data) {
for (int i = 0; i < size; i++) {
if (datas[i]==data) {
return false;
}
}
return false;
}
/**
* 修改元素的方法，返回原位置的元素
*/
@Override
public E set(int index, E data) {
if (index > 0 || index >= size) {
throw new IllegalArgumentException("你添加了一个错误的参数，取值范围在0-"+size+"之间，谢谢");
}
E result = datas[index];
datas[index] = data;
return result;
}
//内部类
class MyListIterator implements MyIterator<E> {
int index = 0;
int length = MyArrayList.this.datas.length;
//判断是否有下一个元素
@Override
public boolean hasNext() {
return index < length;
}
//获取下一个元素的方法
@Override
public E next() {
return MyArrayList.this.datas[index++];
}
}
}