当前位置：首页 > news >正文

【Java】数组

news 来源：原创 2025/4/26 0:34:28

数组是一种用于存储同类型数据的容器结构，其存储规则需遵循Java语言的隐式转换机制：

1. 类型匹配规则

基本数据类型数组仅允许存储与其声明类型兼容的数据

例如：int数组可存储byte/short/int类型（因存在自动类型提升），禁止存储boolean/double等不兼容类型。

2. 建议保持数组类型与存储数据的严格匹配

整数序列（如1, 2, 3）应使用int[]存储

浮点数据（如1.1, 1.2）应使用double[]存储

字符串集合（如"aaa", "bbb"）应使用String[]存储

一、数据的初始化

静态初始化

完整格式：

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};，比如：

int[] arr = new int[]{11,22,33};

double[] arr = new double[]{1.1,1.2,1.3};

简化格式:

数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};，比如：

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

double[] array = {1.1,1.2,1.3};

数组的定义和地址值

package arraydemo;

public class Arraydemo1 {
    public static void main(String[] args) {
        int[] numbers = new int[]{1, 2, 3}; // 动态分配与静态赋值结合
// 可简写为：
        int[] numbers2 = {1, 2, 3};

        double[] prices = new double[]{1.2,1.3,1.4,1.5,1.6};    // 创建长度为5的double数组
        boolean[] flags = new boolean[3];   // 布尔数组默认初始化为false
        String[] namesArr = new String[]{"zhangsan","lisi","wangwu"};
        System.out.println(numbers);
        System.out.println(prices);
        System.out.println(flags);
    }
}

如果直接输出数组名称，那么就会得到地址值

[I@4eec7777
[D@3b07d329  //D是double类型的
[Z@41629346   //Z是bool类型的

Process finished with exit code 0

以[I@4eec7777为例，我们来看一下这个地址值有什么意义呢？

[ ：表示现在打印的是一个数组。
I：表示现在打印的数组是int类型的。
@：仅仅是一个间隔符号而已。
4eec7777：就是数组在内存中真正的地址值。（十六进制的）

动态初始化

数据类型[] 数组名 = new 数据类型[数组长度];
例如：
int[] arr = new int[30];

这里的 数据类型 可以是基本数据类型（如 int、double、boolean 等），也可以是引用数据类型（如 String、自定义类等）；数组名 是你为数组取的标识符；数组长度 是一个正整数，表示数组可以存储元素的数量。

动态初始化时，整数类型默认值为：0

小数类型：0.0

布尔类型：false

字符类型：'\u0000'

引用类型：nul

动态初始化和静态初始化的区别

静态初始化：int[] arr = {1,2,3,4,5};

动态初始化：int[] arr = new int[3];

静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。代码较为简洁，但不够灵活。若要改变数组元素的数量，就需要修改代码里的元素列表。

动态初始化：手动指定数组长度，由系统给出默认初始化值。相对灵活，可依据程序运行时的条件来确定数组的长度。例如可根据用户输入的数量来创建数组。

二、使用数组元素

数组元素的访问

数组中的每个元素都有一个唯一的索引，索引是从 0 开始的整数，用于标识数组中元素的位置。通过索引可以访问数组中的特定元素。

数组名[索引];

public class ArrayAccessExample {
    public static void main(String[] args) {
        // 静态初始化一个整数数组
        int[] numbers = {10, 20, 30, 40, 50};

        // 访问数组中索引为 2 的元素
        int element = numbers[2];
        System.out.println("索引为 2 的元素是: " + element);

        // 访问数组的第一个元素（索引为 0）
        int firstElement = numbers[0];
        System.out.println("数组的第一个元素是: " + firstElement);

        // 访问数组的最后一个元素
        int lastElement = numbers[numbers.length - 1];
        System.out.println("数组的最后一个元素是: " + lastElement);
    }
}

numbers[2]：通过索引 2 访问数组 numbers 中的元素（也就是第三个数字），此时访问到的值是 30。
numbers[0]：访问数组的第一个元素。
numbers[numbers.length - 1]：由于数组索引从 0 开始，所以数组的最后一个元素的索引是数组长度减 1，通过 numbers.length 获取数组的长度。

数组的遍历

数组名.fori 即可生成以下代码（这里我使用的是IntelliJ IDEA 2022.3.2）：

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

我这里就可以直接输入arr.fori，之后Tab一下，就会得到上面这个for循环啦！

下面做个小练习，通过遍历来完成数组的求和：

package arraydemo;

public class arraydemo2 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1, 2, 3, 4, 5,4,3,2};
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum=sum+arr[i];
        }
        System.out.println(sum);
    }
}

数组元素的修改

要修改数组中的元素，同样是通过索引定位到要修改的元素，然后使用赋值语句为其赋予新的值。

数组名[索引] = 新值;

public class ArrayModifyExample {
    public static void main(String[] args) {
        // 动态初始化一个整数数组
        int[] scores = new int[5];

        // 为数组元素赋值
        scores[0] = 80;
        scores[1] = 90;
        scores[2] = 75;
        scores[3] = 85;
        scores[4] = 95;

        // 输出修改前数组中索引为 2 的元素
        System.out.println("修改前，索引为 2 的元素是: " + scores[2]);

        // 修改数组中索引为 2 的元素的值
        scores[2] = 88;

        // 输出修改后数组中索引为 2 的元素
        System.out.println("修改后，索引为 2 的元素是: " + scores[2]);
    }
}

scores[2] = 88;：将数组 scores 中索引为 2 的元素的值修改为 88。