Java超细致讲解数组的使用

数组的定义

数组本质上就是让我们能 " 批量 " 创建相同类型的变量。

数组的三种语法格式

1、 数据类型 [] 数组名称 = new 数据类型 [] { 初始化数据 };

例如：

int[] arr=new int[]{1,2,3};

注意：[]里面不能写数字！！！

2、 数据类型 [] 数组名称 = new 数据类型 [元素个数]；

例如：

public class TsetModer {
   public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       for(int x:arr){
           System.out.print(x+" ");
       }
   }
}

int[] arr=new int[3];

3、 数据类型 [] 数组名称 = { 初始化数据 };

例如：

int[] arr={1,2,3};

注意：[]里面不能写数字！！！

遍历数组的三种方式

1、用for循环遍历数组

例如：

public class TsetModer {
   public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       for (int i = 0; i < arr.length; i++) {
           System.out.print(arr[i]+" ");
       }
   }
}

运行结果：

2、用for-each来遍历数组

举个例子：

public class TsetModer {
   public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       for(int x:arr){
           System.out.print(x+" ");
       }
   }
}

运行结果：

3、借助Java中操作数组的工具类Arrays.toString（将参数的数组以字符的形式输出）

例如：

public class TsetModer {
   public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       System.out.println(Arrays.toString(arr));
   }
}

运行结果：

我们可以看到它打印出来的形式跟上面两种方法都不一样， 我们可以用to.String来模拟实现Arrays.toString。

public class TsetModer {
public static String toString(int[] arr) {
       String str="[";
       for (int i = 0; i < arr.length; i++) {
           str=str+arr[i];
           if(i!=arr.length-1){
               str=str+",";
           }
       }
       str=str+"]";
       return str;
   }
   public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       String ret=toString(arr);
       System.out.println(ret);
   }
}

数组的使用

数组传参

先来看个例子：

public static void main(String[] args) {
       int[] arr = {1, 2, 3};
       func(arr);
       System.out.println("arr[0] = " + arr[0]);
   }
   public static void func(int[] a) {
       a[0] = 10;
       System.out.println("a[0] = " + a[0]);
   }

运行结果：

我们可以知道，在函数内部修改数组内容，函数外部也发生变化。此时arr是一个&ldquo;引用&rdquo;。当arr传参时，是按照引用传参。

引用：引用相当于一个 "别名", 也可以理解成一个指针. 创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.

此时a相当于接收了arr的地址，arr和a同时指向一个数组，当a进行操作数组时，数组内容改变，所以arr[0]和a[0]打印结果一样。

数组的练习

数组拷贝

第一种方法：用for循环遍历数组拷贝

public static int[] copyArr(int[] arr) {
       int[] ret = new int[arr.length];
       for(int i = 0; i < arr.length; i++) {
           ret[i] = arr[i];
       }
       return ret;
   }
   public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       int[] ret=copyArr(arr);
       System.out.println(Arrays.toString(arr));
       System.out.println(Arrays.toString(ret));
   }

运行结果：

第二种方法：

Arrays.copyOf-->库里面的数组拷贝函数

Arrays.copeOf(数组名，数组长度）

举个例子：

public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       int[] ret=Arrays.copyOf(arr,arr.length);
       System.out.println(Arrays.toString(arr));
       System.out.println(Arrays.toString(ret));
   }

运行结果：

第三种方法：

拷贝部分元素-->Arrays.copyRange

Arrays.copyRange(数组名，拷贝开始下标，拷贝结束下标）；

（开始拷贝下标和结束下标是左闭右开！）

举个例子：

public static void main(String[] args) {
       int[] arr={1,2,3,4,5,6};
       int[] ret=Arrays.copyOfRange(arr,2,5);
       System.out.println(Arrays.toString(arr));
       System.out.println(Arrays.toString(ret));
   }

运行结果：

查找数组中的指定元素(二分查找)

public static int binarySearch(int[] arr,int x) {
       int left=0;
       int right=arr.length-1;
       while(left<right){
           int mid=(left+right)/2;
           if(arr[mid]>x){
               right=mid;
           }
           else if(arr[mid]<x){
               left=mid;
           }
           else{
               return mid;
           }
       }
       return -1;
   }
   public static void main(String[] args) {
       int[] arr={1,3,5,7,9};
       int i=binarySearch(arr,5);
       System.out.println("找到了下标是："+i);
   }

判断数组是否有序

public static void main(String[] args) {
       int[] arr={1,2,5,3,4,6};
       System.out.println(bonisOrder(arr));
   }
   public static boolean bonisOrder(int[] arr) {
       for (int i = 0; i < arr.length-1; i++) {
           if(arr[i]>arr[i+1]){
               return false;
           }
       }
       return true;
   }

数组排序(冒泡排序)

public static void bubbleSort(int[] arr) {
       for (int i = 0; i < arr.length-1; i++) {
           for (int j = 0; j <arr.length-i-1 ; j++) {
               if(arr[j]>arr[j+1]){
                   int tmp=arr[j];
                   arr[j]=arr[j+1];
                   arr[j+1]=tmp;
               }
           }
       }
   }
   public static void main(String[] args) {
       int[] arr= {1,6,3,2,7};
       bubbleSort(arr);
       for(int x:arr){
           System.out.print(x+" ");
       }
   }

数组逆序

设定两个下标 , 分别指向第一个元素和最后一个元素 . 交换两个位置的元素。 然后让前一个下标自增 , 后一个下标自减 , 循环继续即可。

public class TsetModer {
   public static void main(String[] args) {
       int[] arr = {1, 2, 3, 4};
       reverse(arr);
       System.out.println(Arrays.toString(arr));
   }
   public static void reverse(int[] arr) {
       int left = 0;
       int right =arr.length - 1;
       while(left < right) {
           int tmp = arr[left];
           arr[left] = arr[right];
           arr[right] = tmp;
           left++;
           right--;
       }
   }

二维数组

二维数组本质上也就是一维数组 , 只不过每个元素又是一个一维数组。

基本语法：

数据类型 [][] 数组名称 = new 数据类型 [ 行数 ][ 列数 ] { 初始化数据 };

看个例子：

public static void main(String[] args) {
       int[][] arr = { {1, 2, 3}, {5, 6, 7, 8}, {9, 10, 11, 12} };
       for (int row = 0; row < arr.length; row++) {
           for (int col = 0; col < arr[row].length; col++) {
               System.out.printf("％d\t", arr[row][col]);
           }
           System.out.println("");
       }
   }

这时候我们可以看到定义了一个三行四列的二位数组arr，但是第0行第3个元素没有给元素，在C语言中默认为0，但是在Java中默认为null。

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作。一旦尝试读写, 就会抛出 NullPointerException。

小结

来源：https://blog.csdn.net/m0_65673419/article/details/124349946