java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java数组Array

Java 数组(Array)存储数据的“排排坐”(最新推荐)

作者:IvanCodes

这篇文章主要介绍了Java 数组(Array)存储数据的“排排坐”(最新推荐),本文通过实例代码给大家介绍的非常详细,感兴趣的朋友一起看看吧

大家好!👋 咱们在编程时,经常需要处理一批相同类型的数据,比如班级里所有同学的成绩 💯、一周每天的最高气温 🌡️、或者购物车里的商品列表 🛒。如果为每个数据都声明一个单独的变量(score1, score2, score3…),那代码不得写“疯”了?🤯

这时候,就轮到 Java 中的一个基础且重要的数据结构登场了——数组 (Array)!你可以把它 想象成一排带编号的储物柜 或者一个鸡蛋托 🥚,专门用来整齐地存放 多个相同类型 的数据。今天,我们就来把数组这个“老朋友”彻底搞明白!

一、 数组到底是个啥?🤔

简单来说,数组就是一个固定大小的容器 📦,里面存放的元素必须是相同的数据类型。

几个关键特性要记住:

二、 创建和使用数组 ✍️

怎么在代码里用数组呢?主要分两步:声明初始化

2.1 声明数组引用

告诉编译器:“我要一个能指向某种类型数组的变量”。

// 推荐的声明方式
int[] scores;
String[] names;
double[] prices;
// C/C++ 风格的声明方式 (也能用,但不推荐)
// int scores[];
// String names[];

注意:这只是声明了一个引用变量,它现在还是 null,并没有指向任何实际的数组内存空间。

2.2 初始化数组(分配空间/赋值)

初始化才是真正创建数组对象、分配内存空间的时候。有两种主要方式:

方式一:使用 new 指定长度

这是最常用的方式,你知道需要多大的数组,但还不确定里面的具体值。

// 创建一个能存放 5 个 int 的数组
scores = new int[5]; // 分配了 5 个 int 的空间
// 创建一个能存放 10 个 String 的数组
names = new String[10]; // 分配了 10 个 String 引用的空间
// 声明和初始化可以合并
double[] salaries = new double[50];

重点📌: 使用 new 创建数组后,里面的元素会被自动赋予默认值

方式二:静态初始化 (直接提供元素值)

如果你在创建数组时就已经知道里面要放哪些元素了,可以用这种更简洁的方式。编译器会根据你提供的值自动确定数组的长度。

// 直接提供初始值,长度由编译器确定 (这里是 4)
int[] initialScores = {90, 85, 92, 78};
// 声明和静态初始化合并
String[] weekdays = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
// 不能分开写!下面这样是错误的 ❌
// int[] numbers;
// numbers = {1, 2, 3}; // 编译错误
// 必须这样写:
int[] numbers;
numbers = new int[]{1, 2, 3}; // 或者声明时就初始化

2.3 访问数组元素:靠索引 [] 👉

数组的核心操作就是通过索引来存取元素。记住:索引从 0 开始! 非常非常重要! 🚨

public class ArrayAccess {
    public static void main(String[] args) {
        String[] fruits = {"Apple <🍎>", "Banana <🍌>", "Orange <🍊>"}; // 长度为 3
        // 访问元素 (索引 0, 1, 2)
        System.out.println("First fruit: " + fruits[0]); // Apple <🍎> (索引 0)
        System.out.println("Second fruit: " + fruits[1]); // Banana <🍌> (索引 1)
        System.out.println("Third fruit: " + fruits[2]); // Orange <🍊> (索引 2)
        // 修改元素
        fruits[1] = "Grape <🍇>"; // 把第 2 个元素 (索引 1) 改成 Grape
        System.out.println("Second fruit now: " + fruits[1]); // Grape <🍇>
        // 尝试访问不存在的索引?后果很严重!
        // System.out.println(fruits[3]); // 运行时错误💥: ArrayIndexOutOfBoundsException
    }
}

2.4 获取数组长度:.length 属性 📏

想知道数组能装多少东西?用 .length 属性(注意:是属性,不是方法,后面没有括号 (),这点和 Stringlength() 方法不同,容易混淆!)。

int[] data = new int[10];
System.out.println("Length of data array: " + data.length); // Output: 10
String[] colors = {"Red", "Green", "Blue"};
System.out.println("Number of colors: " + colors.length); // Output: 3

.length 在循环遍历数组时特别有用。

三、 遍历数组:挨个“点名” 🚶‍♀️🚶‍♂️

遍历数组就是按顺序访问数组中的每一个元素,通常用循环来实现。

3.1 使用传统 for 循环

最灵活的方式,因为你可以拿到当前的索引 i

public class ForLoopArray {
    public static void main(String[] args) {
        double[] readings = {12.5, 13.1, 11.8, 12.9};
        System.out.println("Sensor Readings:");
        // 循环条件通常是 i < array.length
        for (int i = 0; i < readings.length; i++) {
            System.out.println("Reading at index " + i + ": " + readings[i]);
        }
    }
}

3.2 使用增强型 for 循环 (for-each)

如果不需要关心索引,只是想依次处理每个元素,这种方式更简洁、易读。

import java.util.ArrayList; // 只是为了演示集合遍历
import java.util.List;
public class ForEachArray {
    public static void main(String[] args) {
        char[] vowels = {'a', 'e', 'i', 'o', 'u'};
        System.out.print("Vowels: ");
        // 依次取出 vowels 数组中的每个 char 赋给变量 vowel
        for (char vowel : vowels) {
            System.out.print(vowel + " ");
        }
        System.out.println(); // 输出: a e i o u
        // 同样适用于集合 (比如 ArrayList)
        // List<String> names = new ArrayList<>(); ...
        // for (String name : names) { ... }
    }
}

如何选择? 如果需要索引(比如要根据索引修改元素,或者需要知道当前是第几个元素),用传统 for。如果只是读取每个元素的值,增强型 for 通常更好。

四、 数组的“常见烦恼” 😩💥

使用数组时,有几个经典错误你很可能会遇到:

五、 超出基础:多维数组与 Arrays工具类 ▦🛠️

5.1 多维数组

你可以创建“数组的数组”,最常见的是二维数组,可以把它想象成一个表格或矩阵 ▦。

// 创建一个 3行 4列 的 int 二维数组
int[][] matrix = new int[3][4];
// 静态初始化
String[][] board = {
    {"X", "O", "X"},
    {"O", "X", "O"},
    {"X", "O", "X"}
};
// 访问元素需要两个索引
matrix[0][1] = 5; // 设置第 1 行第 2 列 (索引都是从 0 开始)
System.out.println("Board[1][1]: " + board[1][1]); // Output: X

遍历二维数组通常需要嵌套循环。

5.2 java.util.Arrays 工具类 <🛠️>

Java 提供了一个非常有用的 Arrays 类(在 java.util 包下),里面包含了很多操作数组的static方法,能省不少事:

import java.util.Arrays; // <--- 别忘了导入!
public class ArraysUtilDemo {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};
        // 好看的打印方式
        System.out.println("Original array: " + Arrays.toString(nums));
        // 排序
        Arrays.sort(nums);
        System.out.println("Sorted array: " + Arrays.toString(nums));
        // 填充
        int[] filled = new int[5];
        Arrays.fill(filled, -1);
        System.out.println("Filled array: " + Arrays.toString(filled));
        // 复制 (取前 3 个元素)
        int[] copied = Arrays.copyOf(nums, 3); // nums 已经是排序后的 {1, 2, 5, 8, 9}
        System.out.println("Copied first 3: " + Arrays.toString(copied));
    }
}

六、总结 🏁

数组是 Java 中存储固定数量、相同类型元素的基础数据结构。

虽然 ArrayList 等集合类在灵活性上更胜一筹,但数组在性能(尤其是访问速度)和表示固定大小数据集时仍然有其优势,并且是理解集合类的基础。所以,扎实掌握数组非常重要!

七、练练手,检验成果!✏️🧠

来,动手写写代码,巩固一下!

⭐ 基础操作 ⭐

⭐ 循环与计算 ⭐

⭐ 概念辨析 ⭐

八、参考答案 ✅💡

⭐ 基础操作答案 ⭐

1.初始化 prices 数组:

import java.util.Arrays;
public class InitPrices {
    public static void main(String[] args) {
        double[] prices = new double[10];
        // 方法一:使用循环
        // for (int i = 0; i < prices.length; i++) {
        //     prices[i] = 9.99;
        // }
        // 方法二:使用 Arrays.fill (更推荐)
        Arrays.fill(prices, 9.99);
        System.out.println("Initialized prices: " + Arrays.toString(prices));
    }
}

2.修改 colors 数组:

import java.util.Arrays;
public class ModifyColors {
    public static void main(String[] args) {
        String[] colors = {"Red", "Green", "Blue", "Yellow"};
        System.out.println("Original colors: " + Arrays.toString(colors));
        // 第三个元素索引是 2
        if (colors.length > 2) { // 做个简单检查防止越界
            colors[2] = "Purple <💜>";
        }
        System.out.println("Modified colors: " + Arrays.toString(colors));
        // 输出: Modified colors: [Red, Green, Purple <💜>, Yellow]
    }
}

⭐ 循环与计算答案 ⭐

3.计算平均分:

import java.util.Arrays;
public class AverageScore {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 98, 85};
        if (scores.length == 0) {
            System.out.println("Array is empty, cannot calculate average.");
            return;
        }
        int sum = 0;
        for (int score : scores) {
            sum += score;
        }
        // 注意:为了得到精确的小数结果,需要将 sum 或 length 转为 double
        double average = (double) sum / scores.length;
        // 或者 double average = sum * 1.0 / scores.length;
        System.out.println("Scores: " + Arrays.toString(scores));
        System.out.println("Average score: " + average); // 输出: Average score: 87.6
    }
}

4.查找最大值:

import java.util.Arrays;
public class FindMaxValue {
    public static void main(String[] args) {
        int[] data = {5, -2, 9, 15, -8, 1};
        if (data.length == 0) {
            System.out.println("Array is empty.");
            return;
        }
        int max = data[0]; // 假设第一个元素是最大值
        for (int i = 1; i < data.length; i++) {
            if (data[i] > max) {
                max = data[i]; // 如果找到更大的,更新 max
            }
        }
        System.out.println("Data: " + Arrays.toString(data));
        System.out.println("Maximum value: " + max); // 输出: Maximum value: 15
    }
}

⭐ 概念辨析答案 ⭐

5.为什么索引从 0 开始?

这主要是历史原因和底层实现效率的考虑。在 C 语言(Java 的重要祖先)及更早的语言中,数组名通常代表数组第一个元素在内存中的起始地址。访问数组元素 array[i],实际上是计算 起始地址 + i * 每个元素的大小 来找到第 i+1 个元素的地址。如果索引从 0 开始,那么访问第一个元素 array[0] 就是 起始地址 + 0 * size,即起始地址本身,计算最简单、最高效。如果从 1 开始,访问第一个元素 array[1] 就需要计算 起始地址 + (1-1) * size,多了一步减法。这种从 0 开始的索引(称为 zero-based indexing)已经成为 C 家族语言(包括 C++, Java, C#, JavaScript 等)的编程惯例。

6.int[] vs ArrayList<Integer> 区别:

希望这篇关于数组的笔记能帮你打下坚实的基础!用熟了它,再去看集合框架就会感觉轻松很多!如果觉得有帮助,别忘了 点赞👍、收藏⭐、关注 哦!感谢!💖

到此这篇关于Java 基础--数组(Array):存储数据的“排排坐”的文章就介绍到这了,更多相关java数组Array内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

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