目录
[1. 数组的访问](#1. 数组的访问)
[2. 数组的赋值、修改](#2. 数组的赋值、修改)
[4. 数组遍历](#4. 数组遍历)
[Math.random() 方法说明](#Math.random() 方法说明)
一、一维数组
- 数组（Array）是一种基本的数据结构 ，用来存储相同类型的多个元素
- 数组中的每个元素都有一个索引（从0开始），可以通过索引来访问特定位置的元素
- 在Java中，数组一旦创建，其长度是固定的
上面我们知道了什么是数组，那么为什么要使用数组？
1、数据组织的需求
前面我们学习了变量，如果用变量来处理一个班级的成绩太过于麻烦，需要创建上百甚至上千个变量。那么这时就可以使用数组。
2.、批量操作便利
- 可以通过循环轻松遍历所有元素
- 统一处理同类型数据集合
3、内存效率
- 数组在内存中连续存储，访问速度快
- 相比多个独立变量更节省内存管理开销
Java数组的基本特点
- 类型安全：只能存储指定类型的元素
- 固定长度：创建后不能改变大小
- 索引访问：通过下标快速访问元素，时间复杂度O(1)
- 内存连续：元素在内存中顺序排列
上面我们了解了数组，那么下面我们来学习数组的定义和初始化
2、数组的定义和初始化
静态初始化数组
定义的时候已经确认了数据元素，定义和初始化同时进行。
数据类型 [ ] 数组名 = {元素1, 元素2，元素3.....}
数据类型 [ ] 数据名 = new 数据类型[ ]{元素1, 元素2，元素3.....}
如果我们一开始不知道数据中的元素，（数组中的数据需要用户属如）上面的定义就有缺陷了。所以就需要使用另一种定义方式。
动态初始化数组：
- 定义数组时不存入具体的元素值，确认数组存储的数据类型和数组的长度。
数据类型[ ] 数组名 = new 数据类型[长度]；//这里的长度可以是变量int n = 10;
上面的定义我们学会了那么疑问来了：如果使用动态初始化数组，在定义的时候我们并没有给数组赋值。如果我们此时访问数组，数组中都是什么值？在Java数组中，动态初始化数组元素默认值规则。
3、数组的访问，与赋值
此时我们已经学会了数组的定义，接下来我们在讲解数组的使用。
1. 数组的访问
- 数组名[索引]来访问数组。
- 数组是通过下标索引进行访问的，但是需要注意的是，数组第一个元素的下标为0，最后一个元素的下标为数组长度 - 1（length - 1）。
- 在访问数组时候一定要注意访问的范围为0 ~ length - 1，不要越界。
- 如果数组没有初始化，会返回对应类型的默认值。
java
int[] arr = {1, 2, 3};
int n = arr[1]; //这里n就访问到了数组中的第2个元素2.2. 数组的赋值、修改
- 给数组赋值是也是要在对数组做访问。也需要注意下标范围。
java
int []arr = {1, 32, 3};
arr[1] = 2; //这里对数组中的第二个元素的值进行修改如果我们使用动态初始化定义的数组那么我们就需要对数组赋值。
java
public class test {
public static void main(String[] args) {
int []arr = new int[5];
for (int i = 0; i < 5; i++) {
arr[i] = i;
}
}
}3.获取数组的长度
- Java中使用：数组名.length获取数组的长度用int；类型接收。
- length 是数组的属性，不是方法，所以不需要加括号
- 这种方式适用于所有类型的数组（一维、多维等）
- 建议使用 arr.length ，提高代码的健壮性。
java
public class test {
public static void main(String[] args) {
int []arr = new int[5];
int len = arr.length;
System.out.println(len); //5
}
}4. 数组遍历
- 一个一个访问数组元素
方法1：
java
public class test {
//数组的遍历
public static void main(String[] args) {
int []arr = new int[]{1, 2, 3, 4, 5};
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}方法2：
java
public class test {
//数组的遍历
public static void main(String[] args) {
int []arr = new int[]{1, 2, 3, 4, 5};
for(int vol: arr){//这里的vol是数组中的元素值
System.out.println(vol);
}
}
}
注意：
- 增强for循环无法获取当前元素的索引
- for(int vol: arr) 中的 vol 是数组元素的副本。修改 vol 不会影响原数组元素
- 适用于只需要访问数组元素值的场景。
4、练习
例题1.在一个数组中求最值
java
public class test {
//数组的遍历
public static void main(String[] args) {
int []arr = new int[]{9, 2, 99, 4, 5};
System.out.println(getMax(arr));
}
public static int getMax(int[] arr) {
int max = arr[0];
// 遍历数组找到最大值
for (int i = 1; i < arr.length; i++) {
int data = arr[i];
if (max < data) {
max = data;
}
}
return max;
}
}
//结果：
//99案例2：
java
public class test {
//数组的遍历
public static void main(String[] args) {
start();
}
//做牌：创建一个动态初始化数组存储54张牌
public static void start(){
String[] arr = new String[54];
//存储花色
String[] colors = {"♠","♥","♣","♦"};
//存储牌
String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
int index = 0;
for(int i = 0;i < numbers.length;i++){
for(int j = 0;j < colors.length;j++){
arr[index++] = colors[j]+numbers[i];
}
}
arr[index++] = "小王";
arr[index] = "大王";
//打印♠A ♥A ♣A ♦A ♠2 ♥2 ♣2 ♦2 ♠3 ♥3 ♣3 ♦3....
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//把牌洗牌
// 随机打乱数组元素顺序
// 通过遍历数组，为每个位置随机选择另一个位置进行元素交换
for(int i = 0;i < arr.length;i++){
// 生成一个随机索引j，范围在[0, arr.length-1]
int j = (int)(Math.random()*arr.length);
//Math.random()生成随机数，范围在[0, 1)
// 交换arr[i]和arr[j]两个位置的元素
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//打印洗牌后的牌
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + '\t');
}
System.out.println();
}
}Math.random() 方法说明
- 功能：Math.random() 是Java标准库中的静态方法，用于生成随机数
- 返回值：返回一个 double 类型的随机数，范围在 [0, 1) 之间（包含0，不包含1）
- 使用方式：无需创建 Math 类的实例，直接通过类名调用
二、二维数组
前面我们学习了数组，这里我们来学习一下二维数组。
二维数组中的元素还是一个数组。就类似于一张表，有行有列。
1、二维数组的定义和初始化
因为学习了一维数组这里值=只需要类比一维学习即可，所以不详细写了。
java
//初始化二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//二维数组动态初始化数组
int[][] arr2 = new int[5][5];
int[][] arr3 = new int[5][];//不完全初始化，只能省略第二个维度2、二维数组访问、遍历、求行列的长度
访问
- 访问方法：数组名[行索引][列索引]
- 如果二维数组为n行m列，二维数组也是从0开始。最左上角元素索引为[0] [0]，最右下角元素索引为[n - 1][m - 1]
java
//二维数组访问
int arr[][] = {{1,2,3},
{4,5,6},
{7,8,9}};
System.out.println(arr[0][0]);//结果：1遍历
二维数组的遍历需要用到循环嵌套。双层循环。
java
public class test {
public static void main(String[] args) {
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();
}
}
}求长度
java
int arr[][] = {{1,2,3,5},
{4,5,6,6},
{7,8,9,7}};
System.out.println(arr.length); //行
System.out.println(arr[0].length);//列3、二维数组案例（练习）
java
/**
* 测试类，包含主方法和相关工具方法
*/
public class test {
/**
* 程序入口方法，调用start方法处理4x4数组
* @param args 命令行参数
*/
public static void main(String[] args) {
start(4);
}
/**
* 初始化二维数组并打乱其元素顺序
* @param n 二维数组的行列数
*/
public static void start(int n){
// 创建n×n的二维数组
int arr[][] = new int[n][n];
int ant = 1;
// 按顺序填充数组，从1开始递增
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
arr[i][j] = ant;
ant++;
}
}
printArray(arr);
// 打乱二维数组
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
int random1 = (int)(Math.random() * n);
int random2 = (int)(Math.random() * n);
int temp = arr[i][j];
arr[i][j] = arr[random1][random2];
arr[random1][random2] = temp;
}
}
System.out.println("打乱后的数组为：");
printArray(arr);
}
/**
* 打印二维数组
* @param arr 待打印的二维数组
*/
public static void printArray(int[] [] arr){
for (int i = 0; i < arr.length; i++){
for (int j = 0; j < arr[i].length; j++){
System.out.printf("%4d",arr[i][j]);
}
System.out.println();
}
}
}注意：数组名的本质
- Java中的数组名是一个引用（reference），而不是直接的内存地址
- 这个引用指向堆内存中数组对象的存储位置