Java数组补充v2

一、数组基本概念

1**. 什么是数组

数组是Java中用来存储同类型数据 的固定大小 的连续内存空间的数据结构。

2**. 数组特点

固定长度：一旦创建，长度不可改变

相同类型：所有元素必须是同一数据类型

索引访问：通过下标（从0开始）访问元素

内存连续：元素在内存中是连续存储的

arr表示地址，指向arr[]数组的第一个元素。

1. Java 中的数组名是引用（Reference），不是指针

(1) 数组名存储的是数组对象的引用

在 Java 中，数组是对象，数组变量（如 int[] arr）存储的是数组对象的引用（内存地址），而不是数组本身。
例如：

java
复制代码
```
int[] arr = new int[]{1, 2, 3};
```
- arr 是一个引用变量，指向堆内存中的数组对象 {1, 2, 3}。
- 它类似于 C 语言的指针，但 Java 的引用不能进行指针运算（如 arr++），也不能直接操作内存地址。

(2) 引用和指针的区别

对比项	Java 引用（Reference）	C/C++ 指针（Pointer）
内存操作	不能直接操作内存地址	可以直接操作内存（如 `ptr++`）
算术运算	不支持（如 `arr + 1` 非法）	支持（如 `ptr + 1` 合法）
空值表示	`null`	`NULL` 或 `nullptr`
安全性	受 JVM 管理，避免野指针	可能产生野指针、内存泄漏

2. 为什么有人误认为数组名是指针？

(1) 数组变量存储的是地址

在底层，Java 的引用仍然是一个内存地址，类似于指针，但 JVM 隐藏了细节。
例如：

java
复制代码
```
int[] arr = new int[3];
```
- arr 存储的是数组对象在堆内存中的地址，类似于 C 的 int* arr = malloc(3 * sizeof(int));。

(2) 数组作为参数传递时，传递的是引用

在方法调用时，数组是按引用传递（实际上是传递引用的副本，但指向同一个对象），类似于指针传递。

java

复制代码

void modifyArray(int[] a) {
    a[0] = 100;  // 修改会影响原数组
}

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    modifyArray(arr);
    System.out.println(arr[0]);  // 输出 100
}

这与 C 语言传递指针的效果类似：

c
复制代码
```
void modifyArray(int* a) {
    a[0] = 100;
}
```

3. Java 数组引用的特点

(1) 引用可以指向不同的数组对象

java

复制代码

int[] arr = {1, 2, 3};
arr = new int[]{4, 5, 6};  // arr 指向新的数组

类似于 C 的指针可以重新赋值：

c
复制代码
```
int* arr = {1, 2, 3};
arr = (int[]){4, 5, 6};
```

(2) 数组长度固定，但引用可以改变

java

复制代码

int[] arr = new int[3];  // 长度固定为 3
arr = new int[5];        // 引用指向新的数组（长度可变）

在 C 中，需要手动 realloc 或重新分配内存。

二、数组声明与初始化

1. 数组声明

复制代码

// 方式1：数据类型[] 数组名;
int[] arr1;

// 方式2：数据类型 数组名[];
int arr2[];

推荐使用第一种方式，更符合Java规范

2. 数组初始化

(1) 静态初始化

java

int arrB[] = {1,2,3,4,5}
- 这是 静态初始化的简化形式 ，只能在 声明数组变量时 直接使用。
- 编译器会自动推导数组类型和长度。
- 示例：
  
  java
  复制代码
```
int arrB[] = {1, 2, 3, 4, 5}; // 正确
```
arrA = new int[]{1,2,3,4}
- 这是 静态初始化的完整形式 ，可以在 声明时或后续赋值时 使用。
- 需要显式指定数组类型 new int[]，但长度由元素个数决定。
- 示例：
  
  java
  复制代码
```
int[] arrA;
arrA = new int[]{1, 2, 3, 4}; // 正确（先声明后赋值）
```

使用场景不同

场景	`int[] arr = {1,2,3}`	`arr = new int[]{1,2,3}`
声明时直接初始化	✅ 可用	✅ 可用
先声明后赋值	❌ 不可用	✅ 可用
方法返回值	❌ 不可用	✅ 可用
匿名数组传参	❌ 不可用	✅ 可用

示例对比：

java

复制代码

// 1. 声明时初始化（两种方式均可）
int[] arr1 = {1, 2, 3};          // 简化形式
int[] arr2 = new int[]{1, 2, 3}; // 完整形式

// 2. 先声明后赋值（只能用完整形式）
int\[\] arr3;
arr3 = new int\[\]{1, 2, 3}; // 正确
// arr3 = {1, 2, 3}; // 错误！简化形式不能用于后续赋值

// 3. 作为方法返回值（只能用完整形式）
public int\[\] getArray() {
return new int\[\]{1, 2, 3}; // 正确
// return {1, 2, 3}; // 错误！
}

// 4. 匿名数组传参（只能用完整形式）
someMethod(new int\[\]{1, 2, 3}); // 正确
// someMethod({1, 2, 3}); // 错误！

3. 底层实现相同

两种方式最终生成的字节码完全一致，性能无差别。
内存分配方式相同：都在堆内存中创建连续存储的数组对象。

4. 风格建议

推荐使用 int[] arr 声明风格 （而非 int arr[]），更符合 Java 规范。
如果只是 声明时初始化 ，优先使用简化形式 {1,2,3}，代码更简洁。
如果需要 重新赋值或匿名使用 ，必须用完整形式 new int[]{1,2,3}。

特性	`{1,2,3}`	`new int[]{1,2,3}`
语法名称	简化静态初始化	完整静态初始化
是否依赖声明语句	必须与声明写在一起	可独立使用
灵活性	低	高
推荐使用场景	声明时直接初始化	重新赋值、方法返回、匿名传参

(2) 动态初始化

java

复制代码

// 指定长度但不指定元素值
int[] arr = new int[5]; // 默认值为0
String[] strs = new String[3]; // 默认值为null

赋值即逐个元素循环 arraycopy scanner输入赋值都可以

三、数组基本操作

1. 访问数组元素

复制代码

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

// 获取元素
int num = arr[2]; // 获取第3个元素（30）

// 修改元素
arr[3] = 100; // 将第4个元素改为100

2. 获取数组长度

复制代码

int length = arr.length; // 注意不是length()

3. 遍历数组

这里补充循环一定要放在方法中，不能直接在类体内

(1) 普通for循环

复制代码

for(int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

(2) 增强for循环

复制代码

for(int num : arr) {
    System.out.println(num);
}

小练习：

复制代码

//for each 增强for循环
//只是改变了item，没有改变数组也不可以改变,只能做到使用里面的数
//int a=arrB[0]; a=12;
arrB=new int[]{1,2,3,4};
for(int item:arrB){
    item=(int)(Math.random()*100);
}
System.out.println(Arrays.toString(arrB));

//数组随机赋值，然后找出数组最大值
arrB=new int[7];
for(int i=0;i<arrB.length;i++){
    arrB[i]=(int)(Math.random()*100);
}
System.out.println(Arrays.toString(arrB));
int max=arrB[0];
for(int item:arrB){
    if(item>max){
        max=item;
    }
}
System.out.println("数组最大值是："+max);

// 数组求和
arrB=new int[7];
for(int i=0;i<arrB.length;i++){
    arrB[i]=(int)(Math.random()*100);
}
System.out.println(Arrays.toString(arrB));
int sum=0;
for(int item:arrB){
    sum+=item;
}
System.out.println(sum);

//有10个裁判评分，满分为10分，使用随机数模拟，存入数组中
//从中去掉最大分数和最小分数，剩下分数的平均数就是选手得分
//打印出选手得分
//Math.random();//\[0,1) \*10 0-0.9.9999.. (int)一刀切只能取到9 应该\*11
arrB=new int[10];
for(int i=0;i<arrB.length;i++){
    arrB\[i\]=(int)(Math.random()\*11);
}
System.out.println(Arrays.toString(arrB));
max=arrB[0];
int min=arrB[0];
sum=0;
for(int item:arrB){
    if(item>max){
        max=item;
    }
    if(item<min){
        min=item;
    }
    sum+=item;
}

int score=(sum-max-min)/8;
System.out.println(score);

(3) 使用Arrays.toString()

复制代码

System.out.println(Arrays.toString(arr));

四、多维数组

1. 二维数组声明与初始化

复制代码

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

// 动态初始化
int[][] arr2 = new int[3][2]; // 3行2列

2. 二维数组遍历

复制代码

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();
}

五、数组常用工具类Arrays

1. 排序

复制代码

int[] arr = {3, 1, 4, 2, 5};
Arrays.sort(arr); // 升序排序 冒泡插入快速选择。。。。。见后面文章

2. 二分查找

复制代码

int index = Arrays.binarySearch(arr, 4); // 必须是先排序好的才能用二分

3. 数组比较

复制代码

boolean isEqual = Arrays.equals(arr1, arr2);

4. 数组填充

复制代码

Arrays.fill(arr, 0); // 全部填充为0

5. 数组复制

int[] newArr = Arrays.copyOf(arr, arr.length);

6.数组扩容

拷贝数组arraycopy 五个参数

源数组源数组的起始位置(开始复制的位置) 目标数组目标数组的起始位置(从哪个位置开始粘贴) 拷贝的长度

复制代码

//数组扩容 声明一个更大的数组代替旧的数组
int[] arrA=new int[10];
arrA[0]=99;arrA[9]=999;
int[] arrTemp=new int[arrA.length<<1];
System.arraycopy(arrA,0,arrTemp,0,arrA.length);
//原数组 原数组起始位置(从哪个位置开始粘贴) 目标数组 目标数组起始位置 拷贝的长度
arrA=arrTemp;
System.out.println(Arrays.toString(arrA));

六、数组常见问题

1. 数组越界异常

java

复制代码

int[] arr = new int[3];
System.out.println(arr[3]); // ArrayIndexOutOfBoundsException

2. 空指针异常

java

复制代码

int[] arr = null;
System.out.println(arr[0]); // NullPointerException

3. 数组长度不可变

java

复制代码

int[] arr = new int[5];
// arr.length = 10; // 错误！数组长度不可变

七、数组与内存

1. 内存分配

数组变量存储在栈内存
数组元素存储在堆内存

2. 内存示意图

text

复制代码

栈内存        堆内存
arr   ---->  [0][0][0][0][0]

八、数组应用场景

存储大量同类型数据
实现数据结构（如栈、队列）
矩阵运算
排序和搜索算法实现

九、数组与集合的区别

特性	数组	集合(ArrayList等)
长度	固定	动态可变
类型	单一	可泛型指定
性能	高	略低
功能	基础	丰富的方法

十、Java 8+ 数组新特性

1. 并行排序

复制代码

Arrays.parallelSort(arr);

2. Stream操作

复制代码

Arrays.stream(arr)
      .filter(n -> n > 2)
      .forEach(System.out::println);

3. 集合转数组

复制代码

List<String> list = Arrays.asList("A", "B", "C");
String[] arr = list.toArray(new String[0]);

十一、补：无限循环与死循环的区别：

复制代码

//死循环 无限循环
//while(true){} 没有结束条件 死循环
i=-1;
for(;i<0;i--){}//有结束条件，逻辑上条件永远达不到，无限循环

1. 无限循环（Infinite Loop）

定义：

有意创建的 、设计上需要永不停止的循环结构
通常有特定的业务用途，是程序逻辑的一部分

特点：

✅ 是有意设计 的循环结构

✅ 通常包含循环控制机制 （如 break 条件）

✅ 服务于特定业务逻辑（如服务器监听、游戏主循环）

典型应用场景：

java

复制代码

// 服务器主线程循环
while(true) {
    Socket client = serverSocket.accept(); // 等待客户端连接
    new Thread(new ClientHandler(client)).start();
}

// 游戏主循环
while(running) {  // running是可控的布尔变量
    updateGame();
    renderFrame();
}

2. 死循环（Dead Loop）

定义：

意外产生的 、本应终止却无法停止的循环
属于程序缺陷（bug），会导致程序卡死或资源耗尽

特点：

❌ 是无意产生 的程序错误

❌ 缺少正确的终止条件

❌ 会导致程序异常或系统资源耗尽

常见错误示例：

java

复制代码

// 错误1：忘记更新循环变量
int i = 0;
while(i < 10) {  // i永远不会改变
    System.out.println("Stuck...");
}

// 错误2：错误的终止条件
for(int j=1; j!=10; j+=2) { 
    // 当j=9时，j+2=11，永远不等于10
    System.out.println(j);
}

关键对比表

特征	无限循环	死循环
设计意图	有意设计	意外产生
是否可控	有控制机制（可退出）	无法控制
业务价值	实现特定功能	纯属程序缺陷
典型结构	`while(true)` + 内部break	缺少变量更新/错误条件
是否应避免	按需使用	必须修复