Java中的数组（续）
文章目录：
前言：
一、操作数据工具类Arrays与数组练习
1.1数组转字符串
1.2数组的拷贝
1.3 查找数组中指定元素（顺序查找）
1.4查找数组中指定元素（二分查找）
1.5数组排序（冒泡排序）
4.6数组逆序
二、二维数组
2.1 普通的二维数组
2.2 不规则的二维数组
总结：
前言：
上篇文章讲述数组的基本框架，这篇将进一步学习java中的数组
一、操作数据工具类Arrays与数组练习
1.1数组转字符串
int[] array = {1, 2, 3, 4};System.out.println(Arrays.toString(array));结果为：
使用这个方法后续的打印数组会更便捷.
JAVA中提供java.util.Arrays包，其中包含一些操作数组的方法。
1.2数组的拷贝
自己版本的拷贝数组的写法：
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));
结果为：
需要注意的是，数组的拷贝指的是创建一个新数组，将需要拷贝的值拷贝到新数组中。
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引用的不是一个数组
规定范围进行拷贝：
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 查找数组中指定元素（顺序查找）
给定一个数组，再给定一个元素，找出该元素在数组中的位置
代码示例：
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查找数组中指定元素（二分查找）
针对有序数组，可以使用更高效的二分查找
以升序数组为例，二分查找的思路是先取中间位置的元素，然后使用待查找元素与中间元素进行比较;
- 如果相等，即找到了返回该元素在数组的下标
- 如果小于，以类似方法到数组左半侧查找
- 如果大于，以类似方法到数组右半侧查找
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) 进行二分查找
注意：数组元素要有序
//利用工具进行二分查找int[] array = new int[]{1,2,3,4,5};int ret = Arrays.binarySearch(array, 5);System.out.println(ret);
结果为：
1.5数组排序（冒泡排序）
给定一个数组，让数组升序（降序）排列
假设拍升序：
将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
依次从上上述过程，直到数组中所有的元素都排列好
代码：
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）将数组进行排序
代码：
int[] array = new int[]{1,22,31,44,5,8};// 1 5 8 22 31 44System.out.println("排序前"+Arrays.toString(array));Arrays.sort(array);System.out.println("排序后"+Arrays.toString(array));结果为：
4.6数组逆序
给定一个数组，将里面的元素逆序排列
设定两个下标，分别指向第一个元素和最后一个元素，交换两个位置的元素
然后让前一个下标自增，后一个下标自减，进行循环。
代码为：
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 数据类型 [ ] [ ] {初始化数据}
行不可以省略，列可以省略
代码示例：
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二维数据直观图：
二维数组内存存储：
栈上引用存储堆上行数的地址，通过下标访问二维数组元素具体的值。
其中：
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为二维数组第一行的长度
进行二维数组的打印：
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)
int[][] array = {{1,2,3},{4,5,6}};System.out.println(Arrays.deepToString(array));结果为：
2.2 不规则的二维数组
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)
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)
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)