Java数组介绍
在Java中，数组是用来存放同一种数据类型的集合，注意只能存放同一种数据类型(Object类型数组除外)。
1.数组的声明
1
2
3
4
|
int [] myArray = new int[3];
int [] myArray2 = {1,2,3};
|
2.访问数组元素以及给数组元素赋值
1
2
3
4
5
6
|
int [] myArray = new int[3];
myArray[0] = 1;
System.out.println(myArray[0]);
|
3.数组遍历
1
2
3
4
5
|
int [] myArray2 = {1,2,3};
for(int i = 0 ; i < myArray2.length ; i++){
System.out.println(myArray2[i]);
}
|
用类封装数组实现数据结构
ps:假设操作人是不会添加重复元素的，这里没有考虑重复元素，如果添加重复元素了，后面的查找，删除，修改等操作只会对第一次出现的元素有效。
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
| package com.delaunay.Array;
public class MyArray {
private int[] array;
private int elems;
private int length;
public MyArray() {
elems = 0;
length = 50;
array = new int[length];
}
public MyArray(int length) {
elems = 0;
this.length = length;
array = new int[length];
}
public int getSize() {
return elems;
}
public void display() {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public boolean add(int value) {
if (elems == length) {
return false;
} else {
array[elems] = value;
elems++;
}
return true;
}
public int get(int i) {
if (i < 0 || i > elems) {
System.out.println("下标越界");
}
return array[i];
}
public int find(int searchValue) {
int i;
for (i = 0; i < array.length; i++) {
if (array[i] == searchValue)
break;
}
if (i == elems)
return -1;
return i;
}
public boolean delete(int value) {
int k = find(value);
if(k == -1){
return false;
}else {
if (k == elems - 1){
elems--;
}else {
for (int i=k;i<elems-1;i++){
array[i] = array[i+1];
}
elems--;
}
return true;
}
}
public boolean modify(int oldValue,int newValue){
int k = find(oldValue);
if(k == -1){
System.out.println("需要修改的数据不存在");
return false;
}else {
array[k] = newValue;
}
return true;
}
}
|
测试类
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
| package com.delaunay.Array;
public class MyArrayTest {
public static void main(String[] args){
MyArray array = new MyArray(4);
array.add(1);
array.add(2);
array.add(3);
array.add(4);
array.display();
System.out.println(array.get(0));
array.delete(4);
array.modify(3,33);
array.display();
}
}
|
分析数组的局限性
①、插入快，对于无序数组，上面我们实现的数组就是无序的，即元素没有按照从大到小或者某个特定的顺序排列，只是按照插入的顺序排列。无序数组增加一个元素很简单，只需要在数组末尾添加元素即可，但是有序数组却不一定了，它需要在指定的位置插入。
②、查找慢，当然如果根据下标来查找是很快的。但是通常我们都是根据元素值来查找，给定一个元素值，对于无序数组，我们需要从数组第一个元素开始遍历，直到找到那个元素。有序数组通过特定的算法查找的速度会比无需数组快，后面我们会讲各种排序算法。
③、删除慢，根据元素值删除，我们要先找到该元素所处的位置，然后将元素后面的值整体向前面移动一个位置。也需要比较多的时间。
④、数组一旦创建后，大小就固定了，不能动态扩展数组的元素个数。如果初始化你给一个很大的数组大小，那会白白浪费内存空间，如果给小了，后面数据个数增加了又添加不进去了。
