数组
原文链接：https://www.cnblogs.com/JuanF/p/9263901.html
数组
1、数组的几个重要特征
-
连续存储空间（方便查找）
-
数组长度固定（灵活性差）
-
数组中只能存放相同的数据类型
- 数组下标从0开始计算
2、数组的声明定义
//定义int型数组ary0并声明长度为4
int ary0[] = new int[4];
//定义int型数组ary1同时赋初始值
int ary1[] = new int[]{1,2,3,4};
在上面对两个数组的定义中：赋值运算左边为对数组的定义，包括有数组类型、数组名；赋值运算右边为对数组开辟相应数据类型、对应长度的内存空间。
3、数组的遍历
通过ary0.length可以获取数组的长度
int ary0[] = new int[10];
//以数组长度为边界，根据下标对应赋值
for (int i = 0; i < ary0.length; i++) {
ary0[i] = i;
}
//加强for循环，i依次指向数组每个元素，打印输出
for (int i : ary0) {
System.out.println("ary0中第"+i+"个元素："+ary0[i]);
}
输出结果为：
ary0中第0个元素：0 ary0中第1个元素：1 ary0中第2个元素：2 ary0中第3个元素：3 ary0中第4个元素：4 ary0中第5个元素：5 ary0中第6个元素：6 ary0中第7个元素：7 ary0中第8个元素：8 ary0中第9个元素：9
Arrays工具类
Arrays类为java.util包里的一个工具类，提供对数组的一些操作方法，常用的有排序（sort）、填充（fill）、拷贝（copyOf）、查找（binarySearch）、判断相等（equals）等
1、排序（sort）
Arrays.sort() 支持的类型有char、double、int、byte、float等，同时还支持泛型，但需要自己实现Comparator接口
int ary1[] = new int[]{5,23,15,33,24,6,79,19};
//使用Arrys.sort()对ary1进行从小到大排序
Arrays.sort(ary1);
for (int i : ary1) {
System.out.print(i+" ");
}
打印结果为：
5 6 15 19 23 24 33 79
2、填充（fill）
将数组所有元素赋值为统一的填充值，如果对应元素已经有值了，则将覆盖原来的值
//Arrays.fill(int[] a, int val) 的实现：
public static void fill(int[] a, int val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
对数组ary2进行填充，将所有元素填充为9：
int ary2[] = new int[10];
Arrays.fill(ary2, 9);
for (int i : ary2) {
System.out.print(i+" ");
}
最后填充所得到的结果为：
9 9 9 9 9 9 9 9 9 9
3、拷贝（copyOf）
参数：
int[] original：被拷贝的数组
int newLength：被拷贝的长度，即original中被拷贝元素的长度
Arrays.copyOf() 函数会返回一个全新的数组，数组中的元素依次被赋值为orignal数组中前n个元素的值，n即被拷贝的长度，当n大于original数组的长度时，可用来对数组长度进行扩展，扩展部分元素值为0
int ary0[] = new int[]{1,2,3,4,5,6};
int ary1[];
//将ary0前三个元素拷贝给ary1
ary1 = Arrays.copyOf(ary0, 3);
//打印ary1的长度与元素值
System.out.println(ary1.length);
for (int i : ary1) {
System.out.print(i+" ");
}
打印结果为：
3 1 2 3
表明ary0中前3个元素【1，2，3】被复制给了一块新的内存空间，同时ary1指向该空间：
4、二分查找（binarySearch）
- 使用二分查找时，必须先将数组排序
- 一般用在查找元素是否存在
- 如果数组没有排序，结果无法确定
- 如果包含多个指定值，无法保证找到的是哪一个，如果找不到，则返回负数
int ary0[] = new int[]{1,2,5,4,3,6};
//对ary0中3这个元素进行查找
int index = Arrays.binarySearch(ary0, 3);
System.out.println("未排序的数组为：");
showAry(ary0);
System.out.println("未排序进行查找结果："+index);
//对ary0进行排序，再次查找
Arrays.sort(ary0);
System.out.println("排序的数组为：");
showAry(ary0);
index = Arrays.binarySearch(ary0, 3);
System.out.println("排序后进行查找结果："+index);
//ary0指向新的、存在多个相同元素数组
ary0 = new int[]{1,2,3,4,5,2,6,3,8};
//再次进行查找
Arrays.sort(ary0);
System.out.println("多值相同且排序过的数组：");
showAry(ary0);
index = Arrays.binarySearch(ary0, 3);
System.out.println("多值相同进行查找结果："+index);
打印结果为：
未排序的数组为：
1 2 5 4 3 6
未排序进行查找结果：-3
排序的数组为：
1 2 3 4 5 6
排序后进行查找结果：2
多值相同且排序过的数组：
1 2 2 3 3 4 5 6 8
多值相同进行查找结果：4
5、判断相等（equals）
使用Arrays.equals() 判断相等时，进行的是数组各元素的值的比对，而非对ary0和ary1所指向地址的比对，具体实现如下：
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++)
if (a[i] != a2[i])
return false;
return true;
}
区别如下：
int ary0[] = new int[]{1,2,3,4,5};
int ary1[] = new int[]{1,2,3,4,5};
//根据地址判断相等
System.out.println(ary0==ary1);
//根据值判断相等
System.out.println(Arrays.equals(ary0, ary1));
所得打印结果为：
false true
在这里要注意不要将其与object类下的equals()方法搞混了，因为object类的equals方法本质上还是使用的 ”==“ 比较运算符，所以所得结果还将是false
最后是一些练习
将数组 ary0={1,2,3,4,5}、ary1={6,7,8,9,10} 整合成一个新的数组并打印
int ary0[] = new int[]{1,2,3,4,5};
int ary1[] = new int[]{6,7,8,9,10};
//先将ary0拷贝进ary2，数组长度为两数组长度之和
int []ary2 = Arrays.copyOf(ary0,ary0.length+ary1.length);
//打印ary2
showAry(ary2);
//再将ary1中元素通过赋值的方法依次拷贝
for (int i = 0; i < ary1.length; i++) {
ary2[i+ary0.length] = ary1[i];
}
//得到最后结果，打印ary2
showAry(ary2);
得到打印结果如下：
1 2 3 4 5 0 0 0 0 0 1 2 3 4 5 6 7 8 9 10
