Java数组

什么是数组？简单来说，它是一个能够存储多个数据的结构。在不同的语言中，数组的写法各不相同，本文就以 Java 为例，简单介绍一下数组的基本写法。

Java数组

• 1. 格式
• 2. 长度
• 3. 下标与访问元素
• 4. 二维数组
• 5. 常见数组操作
• 6. Java数组拓展工具
• 7. 每日一学-switch语句

1. 格式

（1）创建数组并指定长度

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

int[] ages = new int[3];
float[] income = new float[5];
String[] names = new String[3];

（2）创建数组并直接赋值

数据类型[] 数组名 = {元素1, 元素2, 元素3};

int[] ages = {18, 19, 20};
float[] income = {12.3, 8.9, 10.4, 7.3, 6.5};
String[] names = {"张三", "李四", "王五"};

2. 长度

一个数组的长度表示这个数组可以存储多少个元素，可以通过 数组名.length 来获得数组的长度。例如：

int[] arr = {5,4,3,2,1};
int len = arr.length; // len的值为5，对应arr数组长度为5
int[] arr1 = new int[100];
int len = arr1.length;// len的值为100，对应arr1数组长度为100

3. 下标与访问元素

（1）下标：数组中第一个格子对应的下标是 0，依次递增 1，最后一个下标是 数组名.length – 1。

（2）访问元素：通过 数组名[下标] 来访问。

• 取出：数据类型 变量名 = 数组名[下标];
• 存入、修改：数组名[下标] = 值;

int[] arr = {5, 4, 3, 2, 1}; // 定义数组
int x = arr[3]; // 取出下标为3的元素，x的值为2
arr[2] = 100; // 修改下标为2的元素，arr变为{5, 4, 100, 2, 1}

（3）使用循环批量操作：通过循环遍历下标，即可对数组进行批量操作。

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]); // 依次输出每个元素
}

4. 二维数组

二维数组是一个存储一维数组的数组，可以把它理解为一个「表格」：外层下标表示行，内层下标表示列。

（1）格式：

数据类型[][] 数组名 = new 数据类型[一维数组的个数][一维数组中元素个数];

int[][] arr3 = {
{1, 2, 3, 4},
{1, 2, 3, 4},
{1, 2, 3, 4},
{1, 2, 3, 4},
{1, 2, 3, 4},
{1, 2, 3, 4}
};
int n = arr3[3][2]; // 取出第4行第3列的元素，n的值为3

（2）长度：

• 数组名.length：表示这个二维数组可以存储多少个一维数组（即行数）。
• 数组名[0].length：表示第一个一维数组可以存储多少个元素（即列数）。

5. 常见数组操作

package Frame0808;

public class Test {
static void main(){
int[] arr = {3,2,1,4,5,6,67,7,89,9,0,3,3,1,123,1}; // 定义数组

// 1. 打印所有元素
int len = arr.length;
for (int i = 0; i < len; i++) {
int a = arr[i];
System.out.print(a+" ");
}
System.out.println();

// 2. 查找最小值
int min = arr[0]; // 先假设第一个元素是最小值
for (int i = 0; i < len; i++) {
int a = arr[i];
if(a<min){ // 如果当前元素比 min 还小，就更新 min
min=a;
}
}
System.out.println("最小值："+min);

// 3. 求和并计算平均值
int sum = 0;
for (int i = 0;i < len; i++) {
sum+=i; // 累加下标
}
float average = (float)sum / len; // 强转为 float，避免整数除法丢失小数
System.out.println("总和："+sum+"，平均值："+average);

// 4. 冒泡排序：将数组按从小到大排列
int b = 0; // 临时变量，用于交换两个元素
for (int i = 0;i < len–1; i++) { // 外层循环控制比较的轮数
for (int j = 0;j < len–1; j++) { // 内层循环进行相邻元素比较
if (arr[j] > arr[j+1]) { // 如果前一个比后一个大，就交换
b = arr[j];
arr[j] = arr[j+1];
arr[j+1] = b;
}
}
}
System.out.print("排序后的数组：");
for (int i = 0; i < len; i++) {
int a = arr[i];
System.out.print(a+" ");
}
}
}

输出：

3 2 1 4 5 6 67 7 89 9 0 3 3 1 123 1
最小值：0
总和：120，平均值：7.5
排序后的数组：0 1 1 1 2 3 3 3 4 5 6 7 9 67 89 123

6. Java数组拓展工具

除了手动遍历数组，Java 还提供了 java.util.Arrays 工具类，封装了大量常用方法，可以帮我们省去很多重复代码。使用前先导入包：

import java.util.Arrays;

（1）Arrays.toString(数组)：打印数组内容

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

作用：直接把数组转为字符串打印，不用自己循环遍历。

（2）Arrays.sort(数组)：数组从小到大排序

int[] arr = {5, 2, 9, 1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// [1, 2, 5, 9]

支持 int、double、String、char 数组；默认升序，基本类型数组无法直接简单降序。

（3）Arrays.binarySearch(数组, 查找值)：二分查找

前提：数组必须先排序，否则结果错误。

int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);
System.out.println(index); // 返回下标2

找到返回下标；没找到返回负数。

（4）Arrays.copyOf(原数组, 新长度)：数组复制 + 扩容 / 缩容

int[] oldArr = {10, 20, 30};
int[] newArr = Arrays.copyOf(oldArr, 5);
// newArr = [10, 20, 30, 0, 0]

新长度 > 原长度：扩容，多余位置默认 0 / null；新长度 < 原长度：截取前一部分。

（5）Arrays.copyOfRange(arr, start, end)：区间截取数组

左闭右开：包含 start，不包含 end。

int[] arr = {1, 2, 3, 4, 5};
int[] sub = Arrays.copyOfRange(arr, 1, 4);
// sub = [2, 3, 4]

（6）Arrays.fill(数组, 值)：全部填充统一数值

int[] arr = new int[5];
Arrays.fill(arr, 8);
// arr = [8, 8, 8, 8, 8]

也可以区间填充：Arrays.fill(arr, 1, 3, 9)。

（7）Arrays.equals(数组1, 数组2)：判断两个数组内容是否完全相等

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(Arrays.equals(a, b)); // true

注意：直接 a == b 比较的是地址，不是内容！必须用 equals。

7. 每日一学-switch语句

switch 语句用于多分支判断，根据一个表达式的值，匹配对应的 case 分支执行。相比多个 if-else，switch 结构更清晰、可读性更高。

基本格式：

switch (表达式) {
case 值1:
// 值1 对应的代码
break;
case 值2:
// 值2 对应的代码
break;
default:
// 所有 case 都不匹配时执行
break;
}

核心要点：

• 表达式 的类型可以是 int、char、String等，不能是 long、float、double。
• 每个 case 后面必须是常量，不能是变量或表达式。
• break 用于跳出 switch；漏写 break 会发生「穿透」，继续执行下一个 case，直到遇到 break 或结束。
• default 可选，放在最后，表示所有 case 都不匹配时执行。

示例：

int day = 3;
switch (day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
default:
System.out.println("其他");
break;
}
// 输出：星期三

穿透示例（漏写 break）：

int score = 85;
switch (score / 10) {
case 10:
case 9:
System.out.println("优秀");
case 8:
System.out.println("良好");
default:
System.out.println("继续加油");
}
// 输出：良好
// 继续加油
// 说明：score=85 时 score/10=8，匹配 case 8 输出"良好"；
// 但 case 8 漏写 break，继续穿透到 default 又输出"继续加油"。
// 这就是「穿透」：漏写 break 会继续往下执行，直到遇到 break 或 switch 结束。

巧妙运用穿透：判断月份属于哪个季节

int month = 5;
switch (month) {
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
default:
System.out.println("无效月份");
break;
}
// 输出：春季

这里把相邻的 3 个月份连续写在一起，省略中间的 break，让它们穿透到同一个输出分支，代码比写 12 个 if-else 简洁得多。

小技巧：多个 case 共用同一段代码时，可以像上面这样连续写多个 case，利用穿透特性合并分支。

其实 case 还有一种更为简便的写法：case 值 -> 结果，即 switch 箭头语法（Java 14 及以上版本支持）。

箭头语法格式：

switch (表达式) {
case 值1 -> 结果1;
case 值2 -> 结果2;
default -> 默认结果;
}

使用 -> 后不需要再写 break，每个分支执行完会自动跳出 switch，而且不会发生穿透。上面的“判断月份属于哪个季节”可以简化成：

int month = 5;
String season = switch (month) {
case 12, 1, 2 -> "冬季";
case 3, 4, 5 -> "春季";
case 6, 7, 8 -> "夏季";
case 9, 10, 11 -> "秋季";
default -> "无效月份";
};
System.out.println(season); // 输出：春季

说明：多个值可以写在一个 case 里，用逗号隔开；箭头后面直接写要返回的结果，也就是 case 值 -> 结果，再把整个 switch 的结果用 = 赋值给变量即可，代码更简洁。