Java入门-数组

什么是数组？

数组(Array)是引用数据类型中的一种，是多个相同数据类型的数据按一定顺序排列的集合，并使用一个变量名命名，通过编号的方式对这些数据进行统一管理。数组的下标是从0开始的，同一个数组的元素在内存中是有序且连续存储的。

数组下标从0开始的原因：数组的索引表示了元素距离首地址的偏移量，因为第一个元素的地址与首地址相同，所以偏移量为0，所以下标为0

一维数组

一维数组的声明和初始化

/*
 * 静态初始化
 */
int[] arr1; //数组的声明
arr1 = new int[] {1, 2, 3}; //数组的初始化

int[] arr2 = new int[] {1, 2, 3}; //数组的声明并初始化
int[] arr3 = {1, 2, 3}; //数组的声明并初始化 的简写方式


/*
 * 动态初始化
 */
int[] arr4 = new int[4]; //定义一个元素个数为4的数组

不管是静态初始化还是动态初始化，一旦初始化完成，数组的长度就已经确定了，且长度不可更改

public class Main {
    public static void main(String[] args) {
        int[] arr = {1};
        arr = new int[] {2};
        arr = {1}; // 非法表达式！！！
        arr = new int[1];
    }
}

数组元素的调用

int[] arr = new int[3];
System.out.println(arr[0]); //打印第一个元素：0
System.out.println(arr[3]); //程序报错：ArrayIndexOutOfBoundsException 数组越界异常

arr[0] = 1; //给数组中的第一个元素赋值
arr[3] = 1; //程序报错：ArrayIndexOutOfBoundsException 数组越界异常

获取数组的长度

int[] arr = new int[3];
System.out.println(arr.length); //使用length属性获取数组的长度：3

遍历数组的方法

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

//使用for循环的方法遍历数组
for (i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

//使用增强for循环遍历数组（for-each循环）
for (int num : arr) {
    System.out.println(num);
}

数组元素的默认初始化值

整型元素的默认初始化值：0

浮点型元素的默认初始化值：0.0

布尔型元素的默认初始化值：false

字符型元素的默认初始化值：'\u0000'

String类型(引用类型)元素的默认初始化值：null

int[] arr = new int[3];
System.out.println(arr[0]); //打印：0

内存解析

Java中的内存结构是如何划分的？

分为：程序计数器、虚拟机栈、本地方法栈、堆、方法区。

与数组相关的内存结构

虚拟机栈：用来存放方法中声明的变量（数组名）

堆：用来存放数组的实体（数组中的所有元素）

public class Main {
    public static void main(String[] args) {
        int[] arr1 = new int[4];
        arr1[0] = 10;
        arr1[2] = 20;

        double[] arr2 = new double[2];
        arr2[1] = 1.2;
        arr2 = new double[3];

        int[] arr3 = arr1;
        arr1[1] = 30;
    }
}

二维数组

二维数组其实就是 每个元素都是一维数组的 一维数组。

二维数组的声明和初始化

/*
 * 静态初始化
 */
int[][] arr1 = new int[][] {{1, 2}, {3, 4, 5}};
arr[0][2] = 2; //程序报错：ArrayIndexOutOfBoundsException 数组越界异常

/*
 * 动态初始化
 */
int[][] arr2 = new int[2][3]; //创建一个包含2个一维数组的二维数组，每个一维数组包含3个整型元素
int[][] arr3 = new int[1][]; //创建一个长度为1的二维数组，尚未初始化其元素
arr3[0] = new int[4]; //初始化arr3[0]为一个长度为4的一维数组

获取数组的长度

int[][] arr1 = new int[1][3];
System.out.println(arr1.length); //打印：1
System.out.println(arr1[0].length); //打印：3

int[][] arr2 = {{1, 2}, {2, 3, 4, 5}};
System.out.println(arr2[0].length); //打印：2
System.out.println(arr2[1].length); //打印；4

遍历数组的方法

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

//使用for循环的方法遍历数组
for (row = 0; row < arr.length; row++) {
    for (col = 0; col < arr[row].length; col++) {
        System.out.print(arr[row][col] + "\t");
    }
    System.out.println();
}

//使用增强for循环遍历数组（for-each循环）
for (int[] i : arr) {
    for (int j : i) {
        System.out.print(j + "\t");
    }
    System.out.println();
}

数组元素的默认初始化值

int[][] arr1 = new int[1][];
arr1[0] = new int[1];
System.out.println(arr1); //打印：地址值
System.out.println(arr1[0]); //打印：地址值
System.out.println(arr1[0][0]); //打印：0

int[][] arr2 = new int[1][];
System.out.println(arr2); //打印：地址值
System.out.println(arr2[0]); //打印：null（引用数据类型的默认值）

内存解析

public class Main {
    public static void main(String[] args) {
        int[][] arr1 = new int[2][2];
        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        int[][] arr3 = new int[][]{{1, 2}, {1, 2, 3}};
    }
}

Arrays工具类的使用

判断两个数组是否相等

使用Arrays.equals()方法，两数组相等返回true，不相等返回false

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 4};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals); // 打印：false
    }
}

打印数组元素

使用Arrays.toString()方法

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        String result = Arrays.toString(arr1);
        System.out.println(result); // 打印：[1, 2, 3]
    }
}

数组元素从小到大排序

使用Arrays.sort()方法，使用快速排序算法实现

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {12, 33, 9, 81, 10};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1)); // 打印：[9, 10, 12, 33, 81]
    }
}

查找指定元素

使用Arrays.binarySearch()方法，返回元素的下标，使用二分查找算法实现，使用的前提是数组必须是从小到大排列的

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] arr1 = {12, 33, 9, 81, 10};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1)); // 打印：[9, 10, 12, 33, 81]
        int result = Arrays.binarySearch(arr1, 33);
        System.out.println(result); // 打印：3
    }
}