目录
1.数组的定义与初始化
2.遍历数组
3.认识null
4.引用变量
5.返回多个值
6.数组拷贝
7.数组逆序
8.数组填充
9.小练习
//将整形数组转化为字符串
//二分查找优化
//冒泡排序优化
10.二维数组
//遍历二维数组
//不规则的二维数组
1.数组的定义与初始化
int [ ] arr1 = { 0, 1, 2, 3, 4};
int [ ] arr2 = new int [ ]{ 0, 1, 2, 3, 4};
int [ ] arr3 = new int [5];
注意：1> 不同于C语言中未初始化默认为随机值，Java中未初始化默认为0；
2> 当需要整体初始化时，必须在定义的时候初始化，即不能先定义再初始化；
3> 第二点中用上述arr3中的new方式可以先定义再初始化，但是需要分开初始化；
4> boolean类型数组默认值为false，string类型数组默认值为null（注意是小写）。
2.遍历数组
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
//法一
//获取长度：遍历对象.length
for(int i = 0;i< arr.length;i++){
System.out.print(arr[i]);
}
System.out.println();
//法二：for-each，增强for循环
//把arr中的每个元素都取出来放到x里面
//与for循环区别：无法获取数组下标
for (int x:arr) {
System.out.print(x+" ");
}
System.out.println();
//法三：要导入import java.util.Arrays;
//Java自己将数组里的值以字符串形式组织后进行打印
System.out.println(Arrays.toString(arr));
} 
这里使用了Java自带的方法打印字符串 Array.toString()，顺便说一下排序方法 Array.sort()。
这类方法还有很多，之后碰见了再一一叙述（下方二分查找中就有另一种方法）。
3.认识null
public static void main(String[] args) {
int[] arr = null;//arr这个引用，不指向任何对象
System.out.println(arr.length);//空指针异常
System.out.println(arr[0]);//空指针异常
}null在Java中表示“空引用”，也就是一个不指向对象的引用，作用类似于C语言中的NULL（空指针）
4.引用变量
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5};
int[] arr2 = arr1;
arr2[0] = 9;
System.out.println(Arrays.toString(arr1));//[9, 2, 3, 4, 5]
System.out.println(Arrays.toString(arr2));//[9, 2, 3, 4, 5]
}arr2这个引用指向了arr1这个引用所指向的对象，即arr1和arr2指向同一内存，修改其中任何一个引用另一个也会被修改。
5.返回多个值
public static int[] fun1(){
int[] arr = new int[]{1,2,3,4,5};
return arr;
}
public static int[] fun2(){
int a = 10;
int b = 20;
return new int[]{a,b};
}
public static void main(String[] args) {
int[] ret1 = fun1();
int[] ret2 = fun2();
System.out.println(Arrays.toString(ret1));//[1, 2, 3, 4, 5]
System.out.println(Arrays.toString(ret2));//[10, 20]
}6.数组拷贝
public static int[] copy(int[] arr){
int[] copyArr = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
copyArr[i] = arr[i];
}
return copyArr;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//法一：自己实现
int[] ret1 = copy(arr);
System.out.println(Arrays.toString(ret1));//[1, 2, 3, 4, 5]
//法二：Java自带
int[] ret2 = Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(ret2));//[1, 2, 3, 4, 5]
数组扩容
int[] ret3 = Arrays.copyOf(arr,arr.length*2);
System.out.println(Arrays.toString(ret3));//[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
指定范围拷贝：Arrays.copyOfRange()
int[] ret4 = Arrays.copyOfRange(arr,1,4);//注意：[1,4)，左闭右开
System.out.println(Arrays.toString(ret4));//[2, 3, 4]
指定范围拷贝：System.arraycopy()
int[] ret5 = new int[arr.length];
System.arraycopy(arr,0,ret5,0,arr.length);//拷贝arr.length个元素从arr的0下标处到ret5的0下标处
System.out.println(Arrays.toString(ret5));//[1, 2, 3, 4, 5]
}7.数组逆序
这个与C语言没有什么区别。
public static void reverse(int[] arr){
int i = 0;
int j = arr.length-1;
while(i < j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,};
reverse(arr);
System.out.println(Arrays.toString(arr));
}8.数组填充
public static void main(String[] args) {
int[] arr1 = new int[5];
int[] arr2 = new int[5];
Arrays.fill(arr1,6);//全部填充为6
Arrays.fill(arr2,1,3,8);//[1,3)填充为8
System.out.println(Arrays.toString(arr1));//[6, 6, 6, 6, 6]
System.out.println(Arrays.toString(arr2));//[0, 8, 8, 0, 0]
}9.小练习
//将整形数组转化为字符串
public static String toString(int[] arr){
if(arr == null){
return null;
}
String ret = "[";
int i = 0;
for (i = 0; i < arr.length-1; i++) {
ret += arr[i];
ret += ",";
}
ret += arr[i];
ret += "]";
return ret;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
String ret = toString(arr);
System.out.println(ret);//[1,2,3,4,5]
}
//二分查找优化
public static int findkey(int[] arr,int key){
int left = 0;
int right = arr.length;
while(left <= right){
int mid = (left + right)/2;
if(arr[mid] > key){
right = mid - 1;
}else if(arr[mid] < key){
left = mid + 1;
}else{
return mid;
}
}
return -1;
}
public static void main(String[] args) {
int[] arr = {0,1,2,3,4,5,6,7,8,9};
Scanner scan = new Scanner(System.in);
int key = scan.nextInt();
//法一：自己实现
int ret = findkey(arr,key);
System.out.println(ret);
//法二：Java自带 Arrays.binarySearch
int index = Arrays.binarySearch(arr,key);
System.out.println(index);
}二分查找只能用于有序数组，但有了 Array.sort 和 Array.binarySearch 后，先排序再查找，这样不论是有序还是无序数组都可以查找了，超级方便！！
//冒泡排序优化
public static void bubbleSort (int[] arr){
for (int i = 0; i < arr.length-1; i++) {
boolean flag = false;
for (int j = 0; j < arr.length-1-i; j++) {
if(arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
flag = true;
}
}//当内层循环发现数组已经有序时，flag为false
if(flag == false){
break;
}
}
}
public static void main(String[] args) {
int[] arr = {0,2,4,6,8,1,3,5,7,9};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}相较于之前的冒泡排序，这里增加了flag作为标记，如果内层循环发现数组已经有序，flag就会置为true并且跳出循环，之后的循环就没必要进行了，节省时间。
10.二维数组
定义：int[][] arr1 = {{1,2,3},{4,5,6}};
int[][] arr2 = new int[2][3];
int[][] arr3 = new int[][]{{1,2,3},{1,2,3}};
//遍历二维数组
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5,6}};
System.out.println(arr.length);//2
System.out.println(arr[1].length);//3
//法一：for循环
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
//法二：for-each循环
for (int[] x:arr) {
for (int y:x) {
System.out.print(y+" ");
}
System.out.println();
}
//法三：Arrays.deepToString()
String ret = Arrays.deepToString(arr);
System.out.println(ret);//[[1, 2, 3], [4, 5, 6]]
}//不规则的二维数组
Java中不可省略行，但可省略列
这样一来二维数组就变得十分灵活，可以自定义每一行的列数。
public static void main(String[] args) {
int[][] arr = new int[2][];
arr[0] = new int[3];//第一行列数为3
arr[1] = new int[5];//第二行列数为5
}
