Java数组

Java 数组

在Java中，基本类型（如int、double、char等）是按值传递的，而引用类型（如数组、对象等）也是按值传递的，但传递的是引用的副本。这就意味着，当你将一个数组作为参数传递给方法时，实际上传递的是该数组的引用的副本，而不是数组本身的副本。

• 值传递
  在方法调用时，传递的是变量的值，而不是变量本身。对于基本类型，传递的是变量的值。例如，如果你将一个int类型的变量作为参数传递给方法，实际上传递的是该变量的值。如果方法内部修改了参数的值，不会影响原始的变量。
• 引用传递
  对于引用类型（如数组和对象），传递的是该对象在内存中的地址（引用），而不是对象本身。如果你将一个数组或对象作为参数传递给方法，实际上传递的是该数组或对象在内存中的引用的副本。如果方法内部修改了引用所指向的对象的内容，会影响原始的数组或对象。

1 一维数组

• 数组：也是变量，在内存中开辟一串连续的空间。数组长度一旦确定，就不能修改。

格式:

1. 数据类型[ ] 数组名
2. 数据类型[ ] 数组名称 = new 数据类型[数组长度];
3. 数据类型[ ] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
4. 数据类型[ ] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n}

int[] nums;   //只创建了数组引用名， 并未在内存创建数组空间
int[] nums = new int[3];
int[] nums = {1,2,3};
int[] nums = new int[]{1,2,3};

• 在Java中，可以使用Arrays.toString()方法将数组转换为字符串，以便于输出和调试。

int[] nums = new int[4];
nums = new int[]{4,5,6,7};
System.out.println(Arrays.toString(nums));

输出如下

[4,5,6,7]

2 二维数组

• 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在

格式1：

• 定义了名称为arr的二维数组，二维数组中有3个一维数组
• 每一个一维数组中有2个元素
• 一维数组的名称分别为arr[0], arr[1], arr[2]

int[][] arr = new int[3][2]
arr[0][1] = 6     //给第一个一维数组的第二个下标赋值

格式2：

• 定义了名称为arr的二维数组，二维数组中有3个一维数组

• 每个一维数组都是默认初始化值null (注意：区别于格式1）

• 可以对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[1];arr[2] = new int[2];

int[][] arr = new int[3][];

格式3：

• 定义一个名称为arr的二维数组，二维数组中有三个一维数组
• 每一个一维数组中具体元素也都已初始化
• 第三个一维数组的长度表示方式：arr[2].length;

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

内存结构如下：

3 数组中的常见算法

3.1 二分查找

二分查找算法是一种高效的查找算法，可以在有序表中快速定位目标元素。在顺序有序表中实现二分查找算法的步骤如下：
定义左右指针，分别指向有序表的第一个元素和最后一个元素。
计算中间位置的下标，即 mid = (left + right) / 2。
比较中间位置的元素和目标元素的大小关系：
a. 如果中间位置的元素等于目标元素，则查找成功，返回该元素的下标。
b. 如果中间位置的元素大于目标元素，则目标元素可能在左半部分，将右指针移动到 mid-1 的位置。
c. 如果中间位置的元素小于目标元素，则目标元素可能在右半部分，将左指针移动到 mid+1 的位置。
重复步骤 2-3，直到左指针大于右指针，表示查找失败，返回 -1。

public static int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1; // 表示未找到目标元素
}

在上述代码中，我们定义了一个 binarySearch 方法，该方法接收两个参数，一个是有序数组 arr，另一个是目标值 target。首先，我们定义两个指针 left 和 right，分别指向数组的左端和右端。然后，我们进入循环，每次计算中间元素的下标 mid，并判断中间元素与目标值的大小关系。如果中间元素等于目标值，则查找成功，返回其下标；如果中间元素小于目标值，则在数组右半部分继续查找，将 left 指针指向 mid + 1；如果中间元素大于目标值，则在数组左半部分继续查找，将 right 指针指向 mid - 1。最后，如果循环结束仍未找到目标元素，则返回 -1。

3.2 冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历数组，比较相邻元素并交换它们，如果它们不排序。排序将重复这个过程，直到数组已经排好序为止。

public static void bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
}

以上代码中，bubbleSort 方法实现了冒泡排序。外层循环控制比较次数，内层循环控制每次比较的元素个数。在内层循环中，如果相邻两个元素的顺序不对，就交换它们的位置。

3.3 Arrays工具类

1.Arrays.equals(arr1, arr2)

• 判断两个数组是否相等

int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,2,3,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);

2.Arrays.toString(arr)

• 输出数组信息

System.out.println(Arrays.toString(arr));

3.Arrays.fill(arr,10)

• 将指定值填充到数组之中

Arrays.fill(arr,10);
System.out.println(Arrays.toString(arr));

4.Arrays.sort(arr)

• 对数组进行排序

5.Arrays.binarySearch(arr,0)

• 二分查找

public static void main(String[] args) {
        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
        int index = Arrays.binarySearch(arr,0);
        if(index>0){
            System.out.println(index);
        }else {
            System.out.println("没找到");
        }
}