java自定义动态数组
1、静态数组向动态数组转变
（1）静态数组，数组空间固定长度
这个数组空间总长为4，如果此时新插入一个数据就会报数组空间不足
（2）静态数组如何转变成动态数组
第一步：创建一个空间是data数组两倍的newdata数组（扩容）；
第二步：把data数组中的元素全部赋值到newdata数组；
2、数组扩容程序
|
1
2
3
4
5
6
7
8
|
// 数组扩容private void resize(int newcapacity){ e[] newdata = (e[]) new object[newcapacity]; for (int i = 0; i < size; i++) { newdata[i] = data[i]; } data = newdata;} |
数组添加元素：数组空间不够就会扩容（原来空间2倍）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// 数组指定位置添加元素 public void add(int index, e e) {// if (size == data.length)// throw new illegalargumentexception("add failed.array is full."); if (index < 0 || index > size) throw new illegalargumentexception("add failed. require index >= 0 and index <= size"); if (size == data.length) resize(2 * data.length); for (int i = size - 1; i >= index; i--) data[i + 1] = data[i]; data[index] = e; size++; } |
数组删除元素：数组空间空闲太大就会缩容（原来空间的1/2）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
// 从数组中删除index位置的元素，返回删除的元素public e remove(int index) { if (index < 0 || index >= size) { throw new illegalargumentexception("remove failed.index is illegal"); } e ret = data[index]; for (int i = index + 1; i < size; i++) { data[i - 1] = data[i]; } size--; // loitering objects != memory leak 手动释放内存空间 data[size] = null; if(size == data.length / 2) { resize(data.length / 2); } return ret;} |
3、数组整体代码
|
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
|
public class array<e> { // 定义数组变量，data.length表示数组容量capacity private e[] data; // 定义数组中存放数据大小 private int size; // 有参构造方法，传入数组的容量capacity构造动态数组 public array(int capacity) { data = (e[])new object[capacity]; size = 0; } // 无参构造方法，默认初始容量为capacity=10 public array() { this(10); } // 获取数组中元素个数 public int getsize() { return size; } // 获取数组的容量 public int getcapacity() { return data.length; } // 判断数组是否为空 public boolean isempty() { return size == 0; }/* // 在数组末尾添加元素 public void addlast(e e) { if (size == data.length) throw new illegalargumentexception("addlast failed.array is full."); data[size] = e; size++; }*/ // 在数组末尾添加元素（复用add方法） public void addlast(e e) { add(size, e); } // 在数组头部添加元素（复用add方法） public void addfirst(e e) { add(0, e); } // 数组指定位置添加元素 public void add(int index, e e) {// if (size == data.length)// throw new illegalargumentexception("add failed.array is full."); if (index < 0 || index > size) throw new illegalargumentexception("add failed. require index >= 0 and index <= size"); if (size == data.length) resize(2 * data.length); for (int i = size - 1; i >= index; i--) data[i + 1] = data[i]; data[index] = e; size++; } // 获取index索引位置的元素 public e get(int index) { if (index < 0) { throw new illegalargumentexception("get failed.index is illegal."); } return data[index]; } // 修改index索引位置的元素 public void set(int index, e e) { if (index < 0 || index >= size) { throw new illegalargumentexception("set failed.index is illegal."); } data[index] = e; } // 查找数组中是否存在元素e public boolean contains(e e) { for (int i = 0; i < size; i++) { if (data[i] == e) { return true; } } return false; } // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1 public int find(e e) { for (int i = 0; i < size; i++) { if (data[i] == e) { return i; } } return -1; } // 从数组中删除index位置的元素，返回删除的元素 public e remove(int index) { if (index < 0 || index >= size) { throw new illegalargumentexception("remove failed.index is illegal"); } e ret = data[index]; for (int i = index + 1; i < size; i++) { data[i - 1] = data[i]; } size--; // loitering objects != memory leak 手动释放内存空间 data[size] = null; if(size == data.length / 2) { resize(data.length / 2); } return ret; } // 删除数组第一个元素，返回删除的元素 public e removefirst() { return remove(0); } // 删除数组最后一个元素 public e removelast() { return remove(size - 1); } // 删除数组中指定元素e public void removeelement(e e) { int index = find(e); if (index != -1) { remove(index); } } // 数组扩容 private void resize(int newcapacity){ e[] newdata = (e[]) new object[newcapacity]; for (int i = 0; i < size; i++) { newdata[i] = data[i]; } data = newdata; } // 重写父类tostring()方法 @override public string tostring() { stringbuilder sb = new stringbuilder(); sb.append(string.format("array: size = %d , capacity = %d\n", size, data.length)); sb.append('['); for (int i = 0; i < size; i++) { sb.append(data[i]); if (i != size - 1) { sb.append(','); } } sb.append(']'); return sb.tostring(); }} |
4、数组测试代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public class arraytest { public static void main(string[] args) { // 测试tostring()方法 array<integer> arr = new array(10); for (int i = 0; i < 10; i++) { // 测试addlast(int e)方法 arr.addlast(i); } system.out.println("添加数组元素："); system.out.println(arr); // 测试add(int index, int e)方法 arr.add(1, 200); system.out.println("在数组指定索引位置插入元素e："); system.out.println(arr); // 测试addfirst(int e)方法 arr.addfirst(-10); system.out.println("在数组头部位置插入元素e："); system.out.println(arr); }} |
测试结果如下所示：初始化数组空间大小为10，第一次插入10个元素到数组之后，然后再添加一个元素，此时数组会扩容为原来空间的两倍。
添加数组元素：
|
1
2
|
array: size = 10 , capacity = 10[0,1,2,3,4,5,6,7,8,9] |
在数组指定索引位置插入元素e：
|
1
2
|
array: size = 11 , capacity = 20[0,200,1,2,3,4,5,6,7,8,9] |
在数组头部位置插入元素e：
|
1
|
array: size = 12 , capacity = 20 |
补充：java静态数组和动态数组的定义方式
数组的定义方式
静态：
|
1
2
|
//简化语法常用 定义和初始化同步完成int [] a = {5,2,6,4,10}; |
动态：
|
1
2
|
//数组的定义和初始化同时完成，使用动态初始化语法int[] prices = new int[5]; |
补充：
|
1
2
|
//初始化数组时元素的类型是定义数组时元素类型的子类object[] books = new string[4]; |
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://blog.csdn.net/longgeqiaojie304/article/details/87311625
