文章目录：
[1.3 查找数组中指定元素（顺序查找）](#1.3 查找数组中指定元素（顺序查找）)
[2.1 普通的二维数组](#2.1 普通的二维数组)
[2.2 不规则的二维数组](#2.2 不规则的二维数组)
前言：
上篇文章讲述数组的基本框架，这篇将进一步学习java中的数组
一、操作数据工具类Arrays与数组练习
1.1数组转字符串
java
int[] array = {1, 2, 3, 4};
System.out.println(Arrays.toString(array));结果为：
使用这个方法后续的打印数组会更便捷.
JAVA中提供java.util.Arrays包，其中包含一些操作数组的方法。
1.2数组的拷贝
自己版本的拷贝数组的写法：
java
int[] array1 = new int[]{1,2,3,4};
int[] array2 = new int[array1.length];
System.out.println("拷贝前："+Arrays.toString(array1));
System.out.println("拷贝前："+Arrays.toString(array2));
for (int i = 0; i <array1.length ; i++) {
array2[i] = array1[i];
}
System.out.println("==========");
System.out.println("拷贝后："+Arrays.toString(array1));
System.out.println("拷贝后："+Arrays.toString(array2));结果为：
需要注意的是，数组的拷贝指的是创建一个新数组，将需要拷贝的值拷贝到新数组中。
java
int[] array = new int[]{1,2,3,4};
int[] newarray= Arrays.copyOf(array, array.length);
System.out.println(Arrays.toString(newarray));结果为：
copyOf(int[] original, int newLfan）
使用Arrays.copyof方法完成数组的拷贝：
coypof方法在进行数组拷贝时，创建了一个新的数组。
array和newarray引用的不是一个数组
规定范围进行拷贝：
java
int[] array = new int[]{1,2,3,4};
int[] arr=Arrays.copyOfRange(array,1,3);
System.out.println(Arrays.toString(arr));结果为：
copyOfRange(int[] original, int from, int to)
java中from ... to ... 的取值范围是[ ），无法取到右边的数
注意：
数组当中存储的是基本数据类型时，不论怎么拷贝基本都不会出现问题，但如果存储的时引用数据类型，拷贝时需要考虑深浅拷贝的问题。后续会涉及。
1.3 查找数组中指定元素（顺序查找）
给定一个数组，再给定一个元素，找出该元素在数组中的位置
代码示例：
java
public static int fuc(int[] array,int data) {
for (int i = 0; i <array.length ; i++) {
if (array[i]==data){
return i;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = new int[]{1,2,3,4,5};
int data = 4;
System.out.println(fuc(array, data));
}结果为：
将匹配到的值的下标进行打印
1.4查找数组中指定元素（二分查找）
针对有序数组，可以使用更高效的二分查找
以升序数组为例，二分查找的思路是先取中间位置的元素，然后使用待查找元素与中间元素进行比较;
- 如果相等，即找到了返回该元素在数组的下标
- 如果小于，以类似方法到数组左半侧查找
- 如果大于，以类似方法到数组右半侧查找
java
public static void main(String[] args) {
int[] array = new int[]{1,2,3,4,5};
int data= 5;
int ret = binarySearch(array, data);
if (ret==-1){
System.out.println("没有找到值");
}else {
System.out.println(ret);
}
}
//二分查找
public static int binarySearch(int[] array,int data){
int i = 0;
int j =array.length-1;
while(i<=j){
int mid = (i+j)/2;
if(array[mid]>data){
j = mid -1;
} else if (array[mid]<data) {
i = mid +1;
}else{
return i;
}
}
return -1;
}当针对一个长度为1000个元素的数组查找，二分查找只需要循环14次就能完成循环。
随着数组元素个数越多，二分的优势就越大。
利用工具**Array.binarySearch(int [ ] a , int key)**进行二分查找
注意：数组元素要有序
java
//利用工具进行二分查找
int[] array = new int[]{1,2,3,4,5};
int ret = Arrays.binarySearch(array, 5);
System.out.println(ret);结果为：
1.5数组排序（冒泡排序）
给定一个数组，让数组升序（降序）排列
假设拍升序：
将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
依次从上上述过程，直到数组中所有的元素都排列好
代码：
java
public static void bubbleSort(int[] array){
for (int i = 0; i < array.length-1 ; i++) {
Boolean flg = false ;
for (int j = 0; j <array.length-1-i ; j++) {
if(array[j+1]<array[j]){
int tmp = array[j+1];
array[j+1]=array[j];
array[j]=tmp;
flg = true;
}
}
if (!flg){
break;
}
}
}
public static void main(String[] args) {
int[] array = {1,10,9,5,6};
bubbleSort(array);
System.out.println(Arrays.toString(array));
}结果为：
上述冒泡排序进行了两次的优化。
- j<array.length-1-i： 让 j 在每i次的排序中都少1一次
- if（！flg）：当flg为false时，表示没有进入if语句------》序列有序，进而break循环，避免后续的无效循环，从而优化程序。
冒泡排序性能较低。
JAVA中内置了更高效的排序算法：
利用工具**Arrays.sort（int[] a）**将数组进行排序
代码：
java
int[] array = new int[]{1,22,31,44,5,8};
// 1 5 8 22 31 44
System.out.println("排序前"+Arrays.toString(array));
Arrays.sort(array);
System.out.println("排序后"+Arrays.toString(array));结果为：
4.6数组逆序
给定一个数组，将里面的元素逆序排列
设定两个下标，分别指向第一个元素和最后一个元素，交换两个位置的元素
然后让前一个下标自增，后一个下标自减，进行循环。
代码为：
java
public static void reverse(int[] array){
int i = 0;
int j =array.length-1;
while(i<j){
int tmp = array[i];
array[i]= array[j];
array[j] = tmp;
i++;
j--;
}
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
reverse(array);
System.out.println(Arrays.toString(array));
}结果为：
二、二维数组
2.1 普通的二维数组
二维数组本质上也就是一维数组，只不过每个元素又是一个一维数组.
基本语法：
数据类型[ ] [ ] 数组名称 = new 数据类型 [ ] [ ] {初始化数据}
行不可以省略，列可以省略
代码示例：
java
int[] [] array = new int[][]{{1,2,3,},{4,5,6}};
int[] [] array2 ={{1,2,3,},{4,5,6,}};
int[] [] array1 = new int[2][3]; //0二维数据直观图：
二维数组内存存储：
栈上引用存储堆上行数的地址，通过下标访问二维数组元素具体的值。
其中：
java
int[][] array = {{1,2,3},{4,5,6}};
System.out.println(array.length);
System.out.println(array[0]);
System.out.println(array[0].length);
}打印结果为：
array.length的长度是二维数组的行数
array.[ 0 ]中存储着二维数组第一行首元素的地址
array[0].length为二维数组第一行的长度
进行二维数组的打印：
java
int[][] array = {{1,2,3},{4,5,6}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println();
}结果为：
同时，JAVA中存在工具直接对二维数组以字符串进行时进行打印：
deepToString(Object[] a)
java
int[][] array = {{1,2,3},{4,5,6}};
System.out.println(Arrays.deepToString(array));结果为：
2.2 不规则的二维数组
java
int[][] array = new int[2][];
array[0]= new int[]{1,2,3,4,5};
array[1]=new int[3];
System.out.println(Arrays.deepToString(array));只定义行数时，利用array[ 下标 ]确定列数。
结果为：
现阶段较少使用。
总结：
需要知道些工具：Arrays类的些方法
在这些方法中利用ideal可以看到重载。
二分查找：binarySearch(Object[] a, Object key)
binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
复制：copyOf(int[] original, int newLength)
copyOfRange(int[] original, int from, int to)
比较数组是否相同：equals(int[] a, int[] a2)
java
int[] array = {1,2,3};
int[] array1 = {1,2,3};
Boolean ret = Arrays.equals(array, array1);
System.out.println(ret);------》return boolean
填充：fill(int[ ] a, int fromIndex, int toIndex, int val)
java
int[] array = new int[10];
Arrays.fill(array,2,5,-1); // [2,6)
System.out.println(Arrays.toString(array));排序： sort(int[] a)
一维数组打印：toString(int[] a)
二维数组打印：deepToString(Object[] a)