05-一维,二维数组

1.数组的概念

• 概念：一组连续的存储空间，存储多个相同数据类型的值
• 特点：类型相同，长度固定。

2.数组的创建、访问、遍历

• 创建语法：

  ①声明并分配空间

  数据类型[] 变量名 = new 数据类型[数组大小值];

  int[] arr = new int[5];

  ②先声明，再分配空间

  数据类型[] 变量名;

  变量名 = new 数据类型[数组大小值];

  int[] arr;
  arr = new int[5];

  ③声明并赋值(繁)

  数据类型[] 数组名 = new 数据类型[]{value1, value2, value3, …};

  int[] arr = new int[]{11, 22, 33, 44, 55, 66};

  ④声明并赋值(简)

  数据类型[] 数组名 = {value1, value2, value3, …};

  int[] arr = {11, 22, 33, 44, 55, 66};

• 访问语法：

  数组名[下标];

  arr[2];

• 访问数组长度语法：

  数组名.length

  arr.length

• 遍历数组：

  for (int i = 0; i < arr.length; i++) {
      // arr[i] 使用数组元素
  }

3.数组的组成概述：

• 数组中每个格子称为数组的元素
• 数组的下标从 0 开始，有效范围：0 ~ 数组长度-1
• 数组默认值：整数0, 小数0.0, 字符\u0000, 布尔false, 其他null
• 数组创建之后，长度不可变。

4.数组的扩容

• 思路：创建一个新的更大的数组，将原数组内容复制到新数组中。

• 三种方式：

  1）循环将原数组内容逐一复制到新数组

  2）System.arraycopy(原数组, 原数组起始, 新数组, 新数组起始, 长度);

  3）java.util.Arrays.copyOf(原数组, 新长度); // 返回带有原数组值的新数组

• 地址的替换：数组作为引用类型之一，变量存储的是数组的地址；在元素复制后，需要将新数组的地址赋值给原变量，进行地址替换。

5.数组类型参数和返回值

• 数组参数

  1）引用数据类型赋值/传参，操作的都是地址值

  2）基本数据类型变量无法通过函数传参来修改其原值，只能通过返回值赋值

  3）引用数据类型变量可以通过函数传参/返回值赋值修改，因为操作的是地址

  eg: public static void func(int[] arr) { }

• 数组返回值

  eg: public static int[] func() { }

public class TestParams {
    public static void main(String[] args) {
        int[] arr = new int[]{11, 22, 33, 44, 55};
        
        // 传入arr数组变量
        print(arr);
        System.out.println("src: " + arr.length);
        System.out.println("************************");
        
        m(arr);
        print(arr);
        System.out.println("m(arr): " + arr.length);
        System.out.println("************************");

        arr = m(arr);
        print(arr);
        System.out.println("arr = m(arr): " + arr.length);
    }

    // 数组的参数传递
    public static int[] m(int[] arr) {
        arr[0] = 666;
        arr = java.util.Arrays.copyOf(arr, arr.length*2);

        return arr;
    }
    
    /**
        打印输出整数类型数组元素
        @arr int类型数组
    */
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

6.可变长数组

• 概念：可接收多个同类型实参，个数不限，使用方式与数组相同
• 语法：数据类型… 形参名
• 注意：
  • 支持传递数组类型实参
  • 支持传递零散数据的实参
  • 支持传递的实参的数量为 0~N 个
  • 必须定义在形参列表的最后，且只能有一个
  • method(xxx, xxx[], xxx…) // 对数组的一种便利写法的补充(80%场景使用数组，20%场景使用可变长参数)

public class TestChangeLength {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        
        // 1.可变长形参：支持传递数组类型实参
        method(nums);
        
        // 2.可变长形参：支持传递零散数据的实参
        method(5, 9, 8, 666);
        
        nums = expand(11, 22, 33, 44);
        method(nums);
    }

    // 可变长参数，使用方式与数组无异
    public static void method(int... arr) { // 等价于 int[] arr
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    
    public static int[] expand(int length, int... arr) {
        int[] newNums = new int[length];
        System.arraycopy(arr, 0, newNums, 0, arr.length);
        
        return newNums;
    }
}

7.数组的排序

• JDK排序
  • java.util.Arrays.sort(数组名); // JDK提供，默认升序
  • 降序需要手动进行倒置操作

public class TestJDKSort {
    public static void main(String[] args) {
        int[] nums = {66, 99, 77, 44, 22, 55, 33, 88, 11};
        print(nums);


        // JDK排序 - test
        java.util.Arrays.sort(nums); // 升序
        print(nums); // 11 22 33 44 55 66 77 88 99
        
        // 降序：手动倒置交换值
        for (int i = 0; i < nums.length/2; i++) {
            int tmp = nums[i];
            nums[i] = nums[nums.length-1-i];
            nums[nums.length-1-i] = tmp;
        }
        print(nums); // 99 88 77 66 55 44 33 22 11
    }


     public static void print(int[] arr) {
         for (int i = 0; i < arr.length; i++) {
             System.out.print(arr[i] + " ");
         }
         System.out.println();
     }
}

8.二维数组

• 概念：一维数组中的一维数组；数组中的元素还是数组。

• 高维数组中的每一个元素，存储了低维数组的地址。

• 声明语法：

// 先声明、再分配
  数据类型[][] 数组名;
  数组名 = new 数据类型[高维长度][低维长度];
// 声明并分配空间
  数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];
// 声明并赋值（繁）
  数据类型[][] 数组名 = new 数据类型[高维长度][]; //不规则数组
  数组名[i] = new 数据类型[j]; //自行new低维属组
// 声明并赋值（简）
  数据类型[][] 数组名 = {{v1, v2, v3}, {v4, v5, v6}, {...}}; //显示初始化

public class Test2DArray {
    public static void main(String[] args) {
        int[][] nums = new int[3][5];
        
        nums[0][0] = 10;
        nums[0][3] = 20;
        nums[1][0] = 30;
        nums[1][1] = 40;
        nums[2][2] = 50;
        nums[2][4] = 60;

        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[i].length; j++) {
                System.out.print(nums[i][j] + "\t");
            }
            System.out.println();
        }
        
        System.out.println(nums.length); // 3
        System.out.println(nums[0].length); // 5
        System.out.println();
        System.out.println(nums[0]); // [I@15db9742
        System.out.println(nums[1]); // [I@6d06d69c
        System.out.println(nums[2]); // [I@7852e922
    }
}