数组的基本使用

数组

概述

1. 数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2. 数组相关的概念：
   • 数组名
   • 元素
   • 角标、下标、索引
   • 数组的长度：元素的个数
3. 数组的特点：
   1. 数组是有序排列的
   2. 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
   3. 创建数组对象会在内存中开辟一整块连续的空间
   4. 数组的长度一旦确定，就不能修改
4. 数组的分类：
   • 按照维数：一维数组、二维数组、…
   • 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组一维和多维数组

一维数组

1. 一维数组的声明和初始化
2. 如何调用数组的指定位置的元素
3. 如何获取数组的长度
4. 如何遍历数组
5. 数组元素的默认初始化值
   • 数组元素是整型：0
   • 数组元素是浮点型：0.0
   • 数组元素是char型：0或’\u0000’，而非’0’
   • 数组元素是boolean型：false
   • 数组元素是引用数据类型：null
6. 数组的内存解析

public class ArrayTest {
    public static void main(String[] args) {
        int num;    // 声明
        num = 10;   // 初始化
        int id = 1001;  // 声明 + 初始化
        
        // 1. 一维数组的声明和初始化
        int[] ids;  // 声明
        String names[];
        // 1.1 静态初始化：数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001, 1002, 1003, 1004};
        // 1.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
        names = new String[5];

        // 错误的写法：
//    int[] arr1 = new int[];
//    int[5] arr2 = new int[5];
//    int[] arr3 = new int[3]{1, 2, 3};

        // 也是正确的写法：
        int[] arr4 = {1, 2, 3, 4, 5};   // 类型推断

        // 2. 如何调用数组的指定位置的元素：通过角标的方式调用
        // 数组的角标（或索引）从0开始的，到数组的长度-1结束
        names[0] = "yez";
        names[1] = "yx";

        // 3. 如何获取数组的长度
        // 属性:length
        System.out.println(names.length);   // 5

        // 4. 如何遍历数组
        for(int i = 0; i < arr4.length; i++){
            System.out.println(arr4[i]);
        }
    }
}

内存分析：

二维数组

理解：对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在（从数组底层的运行机制来看，其实没有多维数组）。

1. 二维数组的声明和初始化

2. 如何调用数组的指定位置的元素

3. 如何获取数组的长度

4. 如何遍历数组

5. 数组元素的默认初始化值

   1. 规定：二维数组分为外层数组的元素，内层数组的元素

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

      外层元素：arr[0],arr[1]等

      内层元素：arr[0][0],arr[1][2]等

   2. 针对于初始化方式一：比如：int[][] arr = new int[4][3];

      外层元素的初始化值为：地址值

      内层元素的初始化值为：与一维数组初始化情况相同

   3. 针对于初始化方式二：比如：int[][] arr = new int[4][];

      外层元素的初始化值为：null

      内层元素的初始化值为：不能调用，否则报错

6. 数组的内存解析

public class ArrayTest1 {
    public static void main(String[] args) {
        // 1. 二维数组的声明和初始化
        // 静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
        // 动态初始化1
        String[][] arr2 = new String[3][2];
        // 动态初始化2
        String[][] arr3 = new String[3][];
        
        // 错误的情况
//    String[][] arr4 = new String[][4];
//    String[4][3] arr5 = new String[][];
//    int[][] arr6 = new int[4][3]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

        // 也是正确的写法：
        int[] arr4[] = new int[][]{{1, 2, 3}, {4, 5, 9, 10}, {6, 7, 8}};
        int arr5[][] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};

        // 2. 如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]); // 2
        System.out.println(arr2[1][1]); // null

        arr3[1] = new String[4];
        System.out.println(arr3[1][0]);

        // 3. 获取数组的长度
        System.out.println(arr4.length);    // 3
        System.out.println(arr4[1].length); // 4

        // 4. 如何遍历二维数组
        for(int i = 0; i < arr4.length; i++){
            for(int j = 0; j < arr4[i].length; j++){
                System.out.print(arr4[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

内存分析：

Arrays工具类

java.util.Arrays：操作数组的工具类，里面定义了很多操作数组的方法

public class ArraysTest {
    public static void main(String[] args) {
        // 1.boolean equals(int[] a,int[] b)：判断两个数组是否相等
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 3, 2, 4};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);

        // 2.String toString(int[] a)：输出数组信息
        System.out.println(Arrays.toString(arr1));

        // 3.void fill(int[] a,int val)：将指定值填充到数组之中
        Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));

        // 4.void sort(int[] a)：对数组进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        // 5.int binarySearch(int[] a,int key)：搜索指定的int数组的指定值
        int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int index = Arrays.binarySearch(arr3, 210);
        if(index >= 0){
            System.out.println(index);
        }else{
            System.out.println("未找到");
        }
    }
}