目录
[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]]
学无止境,代码不息。今天的分享就到这儿,有错误或者更好的思路,欢迎大佬们指正交流 🤝📚