java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java数组定义、使用与应用

Java数组定义、使用与核心应用完全指南

作者：GUNFes

Java数组是存储同类型数据的容器,通过固定长度的连续内存空间实现高效存取,这篇文章主要介绍了Java数组定义、使用与核心应用完全指南的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下

一、 数组基础概念

1.1 什么是数组

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

为什么要使用数组呢？

当我们需要存储大量相同类型的数据时，数组是我们的最佳选择。

比如：

// ❌ 不推荐：每个成绩一个变量
int score1 = 70;
int score2 = 80;
// ... 100个成绩需要100个变量

// ✅ 推荐：使用数组
int[] scores = new int[100];  // 一个变量存储100个成绩

可以看到数组可以大大提高我们的效率。

1.2 数组的基本概念

数据类型[] 数组名 = new 数据类型[长度];

如下图：

这是一个数组 其中 

1. array 叫做 引用变量 简称：引用

2. 上面这个数组在创建时并没有直接给定你元素个数，而是直接将具体的数据内容指定 这种叫静态初识化

3.

这两种方法本质上和上面的没什么区别，new是创建新的对象

1. 这种定义方式没有 初始化 当前指定的值 ，默认里面的所有值为0，如果是引用类型默认则是null

2. 这种指定长度，没有给定默认值的叫 动态初始化

二、 数组的内存模型

2.1 基本类型 vs 引用类型

// 基本类型：变量直接存储值
int a = 10;  // 内存中：a -> 10

// 引用类型：变量存储的是地址
int[] arr = new int[]{1, 2, 3};  
// 内存中：arr -> 0x123 (地址) -> [1,2,3]

2.2 内存结构图

在JVM中 有Java虚拟机栈 方法区 本地方法栈 程序计数器 堆 今天我们先来看看栈和堆

如图，假如我们给定一个地址为0x9的array数组 里面有1-5的元素，它在栈和堆是这样表示出来的

2.3 空引用与空指针异常

int[] arr = null;  // arr不指向任何对象

// ❌ 以下都会抛出 NullPointerException
System.out.println(arr.length);
System.out.println(arr[0]);
arr[0] = 10;

调试技巧：遇到NullPointerException，找到报错行，检查那个引用为 null

三、 数组的基本操作

3.1 访问与修改元素

int[] arr = {10, 20, 30, 40, 50};

// 访问：通过下标（从0开始）
System.out.println(arr[0]);  // 输出: 10
System.out.println(arr[4]);  // 输出: 50

// 修改
arr[0] = 100;  // 第一个元素改为100
arr[2] = 300;  // 第三个元素改为300

// ❌ 下标越界
System.out.println(arr[5]);  // 运行时异常：ArrayIndexOutOfBoundsException

3.2 遍历数组的三种方式

int[] arr = {1, 2, 3, 4, 5};

// 方式1：传统for循环（可以获取下标）
for (int i = 0; i < arr.length; i++) {
    System.out.println("下标" + i + ": " + arr[i]);
}

// 方式2：for-each循环（只能获取值，不能改下标）
for (int num : arr) {
    System.out.println(num);
}

// 方式3：while循环（不常用）
int i = 0;
while (i < arr.length) {
    System.out.println(arr[i]);
    i++;
}

3.3 获取数组的长度

int[] arr = {1, 2, 3, 4, 5};
int length = arr.length;  // length = 5
// 注意：length是属性，不是方法，不要加括号！

四、数组的拷贝

4.1 浅拷贝 （共享同一数组）

int[] arr = {1, 2, 3, 4, 5};
int[] newArr = arr;  // 浅拷贝：两个引用指向同一个数组

newArr[0] = 100;  // 修改newArr也会影响arr
System.out.println(arr[0]);  // 输出: 100

4.2 深拷贝 （创建新数组）

深拷贝有三种方式：

方式1：使用Arrays.copyOf

int[] arr = {1, 2, 3, 4, 5};
int[] newArr = Arrays.copyOf(arr, arr.length);  // 深拷贝

newArr[0] = 100;  // 只修改newArr，不影响arr
System.out.println(arr[0]);  // 输出: 1（不变）

方式2：拷贝指定范围

int[] arr = {1, 2, 3, 4, 5};
// 拷贝下标[1,3)范围的元素（左闭右开）
int[] newArr = Arrays.copyOfRange(arr, 1, 3);  // 得到[2, 3]

方式3：手动实现深拷贝

public static int[] copyArray(int[] arr) {
    int[] newArr = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        newArr[i] = arr[i];
    }
    return newArr;
}

五、数组作为方法参数

5.1 传递引用，可以修改数组内容

public static void modifyArray(int[] array) {
    array[0] = 99;  // 会修改原数组
}

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    modifyArray(arr);
    System.out.println(arr[0]);  // 输出: 99（被修改了）
}

5.2 重新赋值不会影响原数组

public static void reassignArray(int[] array) {
    // array指向新对象，不会影响原数组
    array = new int[]{9, 8, 7};
}

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    reassignArray(arr);
    System.out.println(arr[0]);  // 输出: 1（没变）
}

总结：

  1. 方法内部修改数组元素 → 会影响原数组
  2. 方法内部让数组引用指向新对象 → 不会影响原数组                                                        

六、二维数组

6.1 定义和初始化

// 静态初始化
int[][] arr1 = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 动态初始化（指定行列数）
int[][] arr2 = new int[3][4];  // 3行4列

// 动态初始化（只指定行数）
int[][] arr3 = new int[3][];   // 3行，每行长度不同
arr3[0] = new int[2];  // 第0行有2列
arr3[1] = new int[3];  // 第1行有3列
arr3[2] = new int[4];  // 第2行有4列

6.2 遍历二维数组

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int i = 0; i < arr.length; i++) {        // 遍历行
    for (int j = 0; j < arr[i].length; j++) {  // 遍历列
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();  // 换行
}

// 输出：
// 1 2 3
// 4 5 6
// 7 8 9

6.3 获取二维数组信息

int[][] arr = new int[3][4];
System.out.println(arr.length);     // 输出: 3（行数）
System.out.println(arr[0].length);  // 输出: 4（第0行的列数）

七、数组工具类 Arrays

7.1 常用方法

import java.util.Arrays;

int[] arr = {5, 3, 8, 1, 9};

// 1. 数组转字符串（方便打印）
System.out.println(Arrays.toString(arr));  // [5, 3, 8, 1, 9]

// 2. 排序（升序）
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));  // [1, 3, 5, 8, 9]

// 3. 二分查找（必须先排序！）
int index = Arrays.binarySearch(arr, 5);  // 返回下标: 2
int notFound = Arrays.binarySearch(arr, 10);  // 返回负数: -6

// 4. 填充（全部赋相同值）
int[] arr2 = new int[5];
Arrays.fill(arr2, 7);  // [7, 7, 7, 7, 7]

// 5. 比较两个数组是否相等
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(Arrays.equals(a, b));  // true

八、注意事项与常见错误

8.1 必须记住的规则

  1. 下标从0开始：长度为n的数组，下标的范围是[0，n-1]
  2. length是属性：arr.length，不是arr.length()
  3. 数组长度固定：创建后不能改变长度
  4. 引用类型默认为null：String[ ] arr = new String[3]；每个元素都是null  

8.2 常见错误

// ❌ 错误1：下标越界
int[] arr = {1, 2, 3};
System.out.println(arr[3]);  // ArrayIndexOutOfBoundsException

// ❌ 错误2：空指针异常
int[] arr2 = null;
System.out.println(arr2.length);  // NullPointerException

// ❌ 错误3：类型不匹配
// int[] arr3 = {1.0, 2.0, 3.0};  // 编译错误，double不能直接赋给int

// ✅ 正确做法
int[] arr4 = new int[3];
arr4[0] = 1;  // 先创建，后赋值

九、总结要点

  1. 数组是引用类型，存储的是地址，不是值本身
  2. 内存分栈和堆：引用在栈，数组对象在堆
  3. 深拷贝 vs 浅拷贝：理解区别很重要
  4. Arrays 工具类：掌握常用方法，提高效率
  5. 二维数组：本质是 "数组的数组"

到此这篇关于Java数组定义、使用与核心应用完全指南的文章就介绍到这了,更多相关Java数组定义、使用与应用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文