JavaSE通关手册:数组

目录

一、数组的基本概念

[1.1 概念](#1.1 概念)

[1.2 创建&初始化&使用](#1.2 创建&初始化&使用)

二、数组是引用类型

[2.1 初识 JVM 的内存分布](#2.1 初识 JVM 的内存分布)

[2.2 基本类型变量与引用类型变量的区别](#2.2 基本类型变量与引用类型变量的区别)

[2.3 再谈引用变量](#2.3 再谈引用变量)

[2.4 认识 null](#2.4 认识 null)

三、函数中的数组

[3.1 数组作为函数的参数](#3.1 数组作为函数的参数)

[3.2 数组作为返回值](#3.2 数组作为返回值)

[四、数组工具类 Arrays 与数组练习](#四、数组工具类 Arrays 与数组练习)

数组转字符串

数组拷贝

查找元素

数组排序

数组逆序

五、二维数组

[5.1 普通的二维数组](#5.1 普通的二维数组)

[5.2 不规则的二维数组](#5.2 不规则的二维数组)


一、数组的基本概念

1.1 概念

定义:相同类型元素的有序集合,在内存中对应一段连续的存储空间。

数组特点:

**1、**元素在内存中的存储空间是连续的。

2、每个空间都有唯一的编号,起始编号为0,成为数组的下标(索引)。

**3、**数组中所有元素的数据类型必须保持一致。

1.2 创建&初始化&使用

++数组的标准创建格式:++

java 复制代码
T[] 数组名 = new T[N];

语法说明:

**1、**T:数组中存储元素的数据类型。

**2、**T :代表数组本身的类型。

**3、**N:数组的长度,即数组最多能存放的元素个数。

代码示例:

java 复制代码
// 创建一个可以容纳10个int类型元素的数组
int[] array1 = new int[10];
// 创建一个可以容纳5个double类型元素的数组
double[] array2 = new double[5];
// 创建一个可以容纳3个字符串元素的数组
String[] array3 = new String[3];

++动态初始化:++

创建数组时,只指定数组的长度,不手动赋值,数组元素回自动填充默认值。

java 复制代码
// 动态初始化:创建长度为10的int数组,元素自动填充默认值0
int[] array = new int[10];

++静态初始化:++

创建数组时,不直接指定长度(也可以指定长度),而是直接给出数组中要存储的具体数据,编译器会自动根据元素个数推断数组长度。

标准语法格式:

java 复制代码
T[] 数组名 = new T[]{data1,data2,......,datan};

代码示例:

java 复制代码
// 静态初始化int数组,包含10个元素,编译器自动推断长度为10
int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
// 静态初始化double数组
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
// 静态初始化String数组
String[] array3 = new String[]{"hello", "Java", "!!!"};

静态初始化支持简写格式:可以省略 new T ,编译器在编译时会自动还原为完整格式:

java 复制代码
// 简写格式:省略new int[],效果和标准写法完全一致
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hello", "Java", "!!!"};

初始化注意事项:

**1、**动态初始化和标准静态初始化都支持"先声明,后初始化"的两步写法,但简写格式不支持。

**2、**简写格式(省略new T )只能在定义数组的同时使用,不能先声明数组,再用简写格式赋值。

**3、**不推荐C语言风格的写法 int arr = {1,2,3}; Java中 int 整体代表数组类型,写在一起语义更清晰。

两部初始化示例:

java 复制代码
// 先声明数组
int[] array1;
// 后动态初始化
array1 = new int[10];

int[] array2;
// 后静态初始化(必须写完整格式,不能用简写)
array2 = new int[]{10, 20, 30};

// 错误写法:简写格式不能拆分使用
// int[] array3;
// array3 = {1, 2, 3}; // 编译失败

++数组的默认值:++

1、基本数据类型的默认值:

类型 默认值
byte 0
short 0
int 0
long 0
float 0.0f
double 0.0
char '\u0000'
boolean false

2、引用数据类型 的默认值:统一为 null(空引用)

java 复制代码
// 动态初始化String数组,3个元素默认值都是null
String[] words = new String[3];

++数组元素的访问与修改:++

数组通过下标(索引)来访问元素,小标从0开始;因为数组内存是连续的,所以支持**随机访问:**通过下标可以在o(1)时间内直接定位到任意位置的元素,访问效率极高。

如果访问的下标超出的长度范围,程序运行会报错:java.lang.ArrayIndexOutOfBoundsException(数组下标越界异常)。

++数组的遍历:++

求数组的长度通过数组自带的 length属性获取,语法非常简单:

java 复制代码
数组名.length

它返回一个int类型的整数,表示数组中可以容纳的元素总个数。

length注意事项:

**1、**length是属性,不是方法,后面不加括号。

**2、**数组长度一旦创建就固定不变,如果需要扩容,只能创建新数组再将原数组元素拷贝进去。

**3、**数组为null时调用length会抛出空指针异常"NullPointerException"

++空数组的长度是0++

代码示例:

java 复制代码
int[] emptyArr = new int[0];
System.out.println(emptyArr.length); // 输出:0

++二维数组的长度获取:++ 如果是二维数组,数组名.length 获取的是二维数组的行数 ,获取某一行的列数,需要用 数组名行下标.length:

java 复制代码
int[][] arr = {{1,2}, {3,4,5}, {6}};
System.out.println(arr.length);      // 二维数组总行数:3
System.out.println(arr[1].length);   // 下标为1的行的元素个数:3

回归原问题,如何进行数组的遍历,常规的for + 下标 的方法直接省略,来看Java特有的 for-each增强for循环

for-each 是for循环的简化写法,专门用于遍历数组/集合,无需手动管理下标,从语法上避免了下标写错和越界访问问题。

语法格式:

java 复制代码
for (元素类型 变量名 : 数组名) {
    // 循环体,变量代表当前遍历到的元素
}

示例:

java 复制代码
int[] array = {1, 2, 3};
// 依次把数组中的每个元素赋值给x,执行循环体
for (int x : array) {
    System.out.print(x+" ");
}

总结:语法简洁,不会出现下标越界;但无法直接通过该变量修改数组中的元素,适合仅读取元素的场景。


二、数组是引用类型

2.1 初识 JVM 的内存分布

内存是一段连续的存储空间,主要用来存储程序运行时数据。比如:

**1、**程序运行时代码需要加载到内存。

**2、**程序运行产生的中间数据要存放在内存。

**3、**程序中的常量也要保存。

**4、**有些数据可能需要长期存储,而有些数据类型当方法运行结束后就被销毁。

如果对内存中存储的数据不加区分的随意存储,那对内存管理起来将会非常麻烦;因此JVM也对所使用的内存按照功能的不同进行了划分:

JVM 运行时数据区主要分为 5 大区域:

**1、程序计数器(PC Register):**是一块极小的内存空间,作用是保存下一条即将执行的指令的地址,用来控制程序的执行流程,分支、循环、跳转等逻辑都依赖它实现。

2、虚拟机栈(JVM Stack): 与 Java 方法的调用深度绑定,每个方法执行时,都会在虚拟机栈中创建一个对应的栈帧。栈帧中存储了方法内的局部变量、操作数栈、动态链接、方法返回地址等和方法执行相关的全部信息。

**3、本地方法栈(Native Method Stack):**作用和虚拟机栈完全类似,核心区别是:虚拟机栈为 Java 方法服务,本地方法栈为 Native(本地 / C/C++ 实现的)方法服务。

4、堆(Heap): 是 JVM 管理的最大一块内存区域,所有通过new关键字创建的对象,都存储在堆内存中,比如数组对象、普通类的实例对象。

**5、方法区(Method Area):**用于存储已经被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

2.2 基本类型变量与引用类型变量的区别

定义:

基本数据类型变量:变量对应的存储空间中,直接存放的就是数据值本身。

引用类型变量 :也称为对象的引用,变量对应的存储空间中,存储的不是对象本身,而是对象在堆内存中的首地址。

代码示例与内存解析:

java 复制代码
public static void func() {
    // 基本类型变量:栈空间中直接存储数值10
    int a = 10;
    // 基本类型变量:栈空间中直接存储数值20
    int b = 20;
    // 引用类型变量:栈空间中存储数组对象的堆内存地址
    int[] arr = new int[]{1,2,3};
}

内存分布说明:

1、变量a、b、arr都是方法内部的局部变量,因此它们本身都会分配在func方法对应的栈帧中(虚拟机栈)。

2、a 和 b是基本类型,栈空间里直接保存10和20这两个数值。

3、arr是引用类型(数组类型),栈空间里保存的是数组对象在堆中的首地址(可简单理解为内存编号);而数组真正的元素数据存储在堆内存中。

2.3 再谈引用变量

引用赋值与同对象修改

java 复制代码
public static void func() {
    // 1. 创建长度为3的int数组,array1是引用变量,指向第一个数组对象
    int[] array1 = new int[3];
    // 给第一个数组的元素赋值
    array1[0] = 10;
    array1[1] = 20;
    array1[2] = 30;

    // 2. 创建长度为5的int数组,array2是引用变量,指向第二个数组对象
    int[] array2 = new int[]{1,2,3,4,5};
    // 修改第二个数组的前两个元素
    array2[0] = 100;
    array2[1] = 200;

    // 3. 引用赋值:把array2中存储的地址,拷贝给array1
    // 执行后,array1和array2指向堆中同一个数组对象(第二个数组)
    array1 = array2;

    // 4. 通过array1修改数组的元素
    array1[2] = 300;
    array1[3] = 400;
    // 5. 通过array2修改数组的元素
    array2[4] = 500;

    // 6. 遍历打印array2的所有元素
    for (int i = 0; i < array2.length; i++) {
        System.out.println(array2[i]);
    }
}

图像解释:

2.4 认识 null

null 的含义

null在Java中表示空引用,意思是这个引用变量不指向任何对象。类似于C语言中的NULL

java 复制代码
// 声明一个int数组引用变量arr,赋值为null,表示不指向任何数组对象
int[] arr = null;
// 错误:通过空引用访问数组元素,会抛出空指针异常
System.out.println(arr[0]);

null的注意事项:

**1、空引用不能进行任何对象操作:**只要引用的值是null,无论是访问数组元素、调用方法、访问属性,都会抛出 NullPointerException(空指针异常)。

**2、**null 只能赋值给引用类型:基本数据类型变量不能赋值为null,只有数组、类、接口等引用类型才能接收 null。

3、null 和 0 地址没有关联:Java 规范中并没有约定 null 对应内存的 0 号地址,它只是一个特殊的、表示 "不指向任何对象" 的标识。

**4、**null ≠ 长度为 0 的数组。


三、函数中的数组

3.1 数组作为函数的参数

Java 中所有参数传递本质都是值传递,数组作为引用类型,作为方法参数时的传递效果,和基本数据类型有本质区别。

基本数据类型传参时,传递的是变量值的副本。方法内修改形参,只是修改了副本的值,不会影响方法外的实参变量。

数组是引用类型,变量中存储的是数组对象的堆内存地址。数组作为参数传递时,传递的是地址值的副本------ 形参和实参会指向堆中同一个数组对象。

示例代码如下:

java 复制代码
public static void main(String[] args) {
    // 实参arr,存储数组的堆内存地址
    int[] arr = {1, 2, 3};
    // 将arr中的地址值拷贝一份,传递给func方法的形参a
    func(arr);
    // 方法执行后,堆中数组已被修改,实参可直接看到变化
    System.out.println("arr[0] = " + arr[0]);
}

/**
 * 接收int数组类型参数的方法
 * @param a 形参,保存实参的地址副本,和实参指向同一个堆数组
 */
public static void func(int[] a) {
    // 通过形参修改堆中数组的元素
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}

注意:

1、本质仍是值传递:只不过传递的值是数组的内存地址,而非数据本身。

2、仅修改元素有效,重新赋值无效:如果在方法内给形参重新赋值(让它指向一个新数组),只会改变形参自身的地址值,完全不会影响外部实参。

代码示例:

java 复制代码
public static void func(int[] a) {
    // 给形参重新赋值,指向全新的数组对象
    a = new int[]{10, 20, 30};
    // 后续修改只作用于新数组,外部实参完全不受影响
}

3.2 数组作为返回值

当一个方法需要返回多个同类型结果时,可以将结果封装在数组中,作为返回值一次性返回。

示例:获取斐波那契数列的前N项

java 复制代码
public class TestArray {
    public static int[] fib(int n){
        // 非法参数校验
        if(n <= 0) return null;

        // 创建长度为n的数组,存储计算结果
        int[] array = new int[n];
        // 第一项固定为1
        array[0] = 1;
        // 只有n≥2时才给第二项赋值,避免下标越界
        if(n >= 2) array[1] = 1;

        // 从第三项开始,每一项 = 前两项之和
        for(int i = 2; i < n; i++){
            array[i] = array[i-1] + array[i-2];
        }
        
        return array;
    }

    public static void main(String[] args) {
        // 获取前10项斐波那契数列
        int[] array = fib(10);

        // 非空校验,避免空指针异常
       if(array != null){
            for(int x: array) {
                System.out.print(x+" ");
            }
        }
    }
}

四、数组工具类 Arrays 与数组练习

java.util.Arrays是Java官方提供的数组工具类,封装了大量操作数的常用方法,无需手动实现,直接调用即可大幅提升开发效率。

数组转字符串

Arrays.toString(数组):将数组转换为格式规整的字符串,自动拼接 [] 和逗号分隔,替代手动循环拼接。

代码:

java 复制代码
import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        // 直接打印数组名只会输出内存地址哈希值
        System.out.println(arr); // 输出类似 [I@1b6d3586
        // 使用Arrays.toString打印数组完整内容
        String str = Arrays.toString(arr);
        System.out.println(str); // 输出 [1, 2, 3, 4, 5]
    }
}

补充说明:Arrays.toString() 仅适用于一维数组;多维数组需要使用 Arrays.deepToString() 才能完整打印所有层级的元素。

数组拷贝

完整拷贝

Arrays.copyOf(原数组,新数组长度):会在堆中创建一个全新的数组对象,将原数组的元素逐个复制到新数组中。两个数组是完全独立的对象,修改其中一个不会影响另一个。

代码:

java 复制代码
import java.util.Arrays;

public static void myCopy(){
    int[] arr = {1,2,3,4,5,6};

    // 拷贝数组,新数组长度和原数组一致
    int[] newArr = Arrays.copyOf(arr, arr.length);
    System.out.println("newArr: " + Arrays.toString(newArr));

    // 修改原数组的元素
    arr[0] = 10;
    // 新数组完全不受影响
    System.out.println("arr: " + Arrays.toString(arr));
    System.out.println("newArr: " + Arrays.toString(newArr));
}

区间拷贝

Arrays.copyOfRange(原数组,from,to)可以拷贝数组的指定片段,**区间规则为左闭右开:**包含下标from的元素,不包含下标to的元素。

代码:

java 复制代码
// 拷贝arr中下标2到3的元素(不包含下标4)
int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));

深浅拷贝:

1、当数组存储基本数据类型时,Arrays.copyOf 属于完整拷贝,新旧数据完全独立。

2、当数组存储引用数据类型时,拷贝的只是对象的内存地址,新旧数组的元素仍指向同一个对象,属于浅拷贝。深拷贝需要逐个复制对象本身,面向对象部分会详细讲解。

查找元素

顺序查找

遍历数组的每一个元素,依次和目标值比较;这里省略。

二分查找

Arrays.binarySearch(有序数组,目标值),工具类对应方法,底层就是二分查找实现。

二分查找也叫折半查找,只能用于已经排好序的数组。

代码:

java 复制代码
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    // 查找6在有序数组中的下标
    System.out.println(binarySearch(arr, 6));
}

/**
 * 二分查找(适用于升序数组)
 * @param arr 升序排列的数组
 * @param toFind 要查找的目标值
 * @return 元素下标,未找到返回-1
 */
public static int binarySearch(int[] arr, int toFind) {
    int left = 0;                // 左边界下标
    int right = arr.length - 1;  // 右边界下标

    // 循环条件:左边界不超过右边界
    while (left <= right) {
        // 计算中间位置下标
        int mid = (left + right) / 2;

        if (toFind < arr[mid]) {
            // 目标值更小,去左半区间查找,右边界左移
            right = mid - 1;
        } else if (toFind > arr[mid]) {
            // 目标值更大,去右半区间查找,左边界右移
            left = mid + 1;
        } else {
            // 元素相等,找到目标,返回下标
            return mid;
        }
    }
    // 循环结束仍未找到
    return -1;
}

数组排序

冒泡排序

java 复制代码
public static void bubbleSort(int[] arr){
        for(int i = 0; i < arr.length - 1;i++){
            boolean flag = false; // 对冒泡排序进行性能优化
            for(int j = 0; j < arr.length - 1 - i;j++){
                if(arr[j] > arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    flag = true;
                }
            }
            if(!flag) return;
        }
    }
    public static void main(String[] args){
        // 测试冒泡排序
        int[] arr2 = {999,888,777,666};
        bubbleSort(arr2);
        for(int x:arr2){
            System.out.print(x+" ");
        }
    }

内置排序方法

Arrays.sort()封装了优化后的高效排序算法,性能远高于冒泡排序,工程开发可直接调用。

java 复制代码
import java.util.Arrays;

public static void main(String[] args) {
    int[] arr = {9, 5, 2, 7};
    // 直接调用内置排序,默认升序排列
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}

数组逆序

双指针法(原地逆序)

代码:

java 复制代码
import java.util.Arrays;

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

/**
 * 数组原地逆序
 * @param 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--;
    }
}

五、二维数组

5.1 普通的二维数组

本质

二维数组本质上是一个特殊的一维数组 ------ 它的每个元素,又是一个一维数组。

可以理解为 "数组的数组":外层一维数组的每个格子,存放着一个内层一维数组的内存地址。

基本语法

动态初始化

java 复制代码
// 定义一个3行4列的二维数组:3个一维数组,每个一维数组长度为4
int[][] arr = new int[3][4];

第一个中括号的数字:二维数组的行数(外层一维数组的长度)

第二个中括号的数字:每个一维数组的列数(内层一维数组的长度)

元素访问

通过 **数组名行下标列下标**访问元素,行、列下标均从0开始。

java 复制代码
// 获取第0行第1列的元素,值为2
int num = arr[0][1];
// 修改第2行第0列的元素
arr[2][0] = 100;

长度属性:

**1、**arr.length:获取二维数组的行数。

**2、**arri.length:获取第i行的列数。

二维数组的遍历

双层for循环遍历此处省略......

增强for循环访问二维数组

代码示例:

java 复制代码
public class TwoDForEach {
    public static void main(String[] args) {
        // 定义3行4列的二维数组
        int[][] arr = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        // 双层for-each遍历二维数组
        // 外层:每次取出一行(一个一维数组)赋值给row
        for (int[] row : arr) {
            // 内层:遍历当前行row的每一个元素,赋值给num
            for (int num : row) {
                // 格式化输出,制表符对齐
                System.out.printf("%d\t", num);
            }
            // 一行打印完毕,换行
            System.out.println();
        }
    }
}

5.2 不规则的二维数组

概念

不规则二维数组也叫锯齿数组,指二维数组中每一行的一维数组长度可以不相同,也就是每行的列数可以不一样。

创建方式

创建时只指定行数,不指定列数;之后逐行为每个内层一维数组单独分配长度。

代码:

java 复制代码
public class IrregularArrayDemo {
    public static void main(String[] args) {
        // 1. 创建外层二维数组:指定行数为2,不指定列数
        // 此时外层数组的2个元素默认值都是null,还没有指向具体的一维数组
        int[][] array = new int[2][];

        // 2. 给第0行分配空间:创建长度为3的一维数组
        array[0] = new int[3];
        // 3. 给第1行分配空间:创建长度为5的一维数组
        array[1] = new int[5];

        // 遍历验证每行的长度
        for (int row = 0; row < array.length; row++) {
            System.out.println("第" + row + "行的长度:" + array[row].length);
        }
    }
}

不规则数组的静态初始化

也可以直接通过静态初始化创建不规则二维数组,无需手动逐行分配:

java 复制代码
int[][] arr = {
    {1, 2, 3},        // 第0行:3列
    {4, 5},           // 第1行:2列
    {6, 7, 8, 9}      // 第2行:4列
};

注意事项:

**1、**遍历不规则二维数组时,必须使用 arrrow.length 获取当前行数的列数,不能使用固定列数,否则会出现线标越界。

**2、**如果只创建了外层数组、没有给行分配一维数组,直接访问 arrrowcol 会抛出空指针异常。

二维数组打印方法:

一维数组使用 Arrays.toString() 打印,二维数组需要使用 **Arrays.deepToString()**才能打印完整所有层级的元素:

代码:

java 复制代码
import java.util.Arrays;

int[][] arr = {{1,2}, {3,4,5}};
System.out.println(Arrays.deepToString(arr));
// 输出:[[1, 2], [3, 4, 5]]

学无止境,代码不息。今天的分享就到这儿,有错误或者更好的思路,欢迎大佬们指正交流 🤝📚

相关推荐
风落青芜5 小时前
数据结构:堆的概念与实现
c语言·开发语言·数据结构·算法
老师我太想进步了20262 天前
【数据结构-8】栈的实现
c语言·数据结构·算法
【心态好不摆烂】3 天前
数据结构基础精讲3
数据结构·算法
岑梓铭3 天前
《考研408数据结构》第七章(B树 和 B+树)复习笔记
数据结构·笔记·b树·考研·408
岑梓铭3 天前
《考研408数据结构》第八章(排序)复习笔记
数据结构·笔记
nice_lcj5204 天前
LRU 缓存入门:它是什么、怎么用、面试怎么手写
java·数据结构·缓存·面试·lru
꧁细听勿语情꧂4 天前
直接选择排序,堆排序,冒泡排序,递归快速排序、hoare版本、挖坑法、lomuto前后指针,非递归快速排序
c语言·开发语言·数据结构·算法
Pniubi5 天前
关于算法用现成数据结构和手撕
数据结构
老师我太想进步了20265 天前
【数据结构-6】算法美学之单链表(1)
数据结构·算法