Java数组类型

Java 数组类型

数组是 Java 中用于存储固定大小的同类型元素的数据结构。数组在 Java 中是对象，存储在堆内存中。

一、数组声明与初始化

1. 声明数组

// 声明语法
数据类型[] 数组名;  // 推荐方式
数据类型 数组名[];  // C风格，不推荐

// 示例
int[] numbers;     // 整型数组
String[] names;    // 字符串数组
double prices[];   // 不推荐这种声明方式

2. 初始化数组

(1) 静态初始化（声明时初始化）

// 完整语法
int[] nums = new int[]{1, 2, 3, 4, 5};

// 简化语法
String[] fruits = {"Apple", "Banana", "Orange"};
char[] vowels = {'a', 'e', 'i', 'o', 'u'};

(2) 动态初始化（指定长度）

// 语法：new 数据类型[长度]
int[] scores = new int[5];      // 5个int元素，默认值0
boolean[] flags = new boolean[3]; // 3个boolean元素，默认false
String[] words = new String[4];  // 4个String元素，默认null

二、数组访问与操作

1. 访问数组元素

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

// 通过索引访问（索引从0开始）
System.out.println(arr[0]);  // 10
System.out.println(arr[2]);  // 30

// 修改元素
arr[1] = 200;  // 数组变为 {10, 200, 30, 40, 50}

// 错误示例：数组越界
// System.out.println(arr[5]);  // ArrayIndexOutOfBoundsException

2. 获取数组长度

int[] numbers = {1, 2, 3};
System.out.println(numbers.length);  // 3 (不是方法，是属性)

3. 遍历数组

(1) for循环

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

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

(2) 增强for循环（foreach）

String[] names = {"Alice", "Bob", "Charlie"};

for (String name : names) {
    System.out.println(name);
}

(3) 使用Arrays.toString()

import java.util.Arrays;

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

三、多维数组

1. 二维数组

// 声明和初始化
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 动态初始化
double[][] table = new double[3][4];  // 3行4列

// 访问元素
System.out.println(matrix[1][2]);  // 6
matrix[0][1] = 20;  // 修改元素

// 遍历二维数组
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

2. 不规则数组

// 每行长度可以不同
int[][] irregular = new int[3][];
irregular[0] = new int[2];
irregular[1] = new int[3];
irregular[2] = new int[1];

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

四、数组工具类 Arrays

java.util.Arrays 提供了许多实用方法：

import java.util.Arrays;

int[] arr = {5, 3, 9, 1, 7};

// 排序
Arrays.sort(arr);  // [1, 3, 5, 7, 9]

// 二分查找（必须先排序）
int index = Arrays.binarySearch(arr, 5);  // 2

// 填充
int[] filled = new int[5];
Arrays.fill(filled, 10);  // [10, 10, 10, 10, 10]

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

// 复制数组
int[] copy = Arrays.copyOf(arr, arr.length);
int[] rangeCopy = Arrays.copyOfRange(arr, 1, 3);  // [3, 5]

// 转换为字符串
System.out.println(Arrays.toString(arr));  // [1, 3, 5, 7, 9]

五、数组常见操作

1. 数组复制

// System.arraycopy()
int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(source, 0, dest, 0, source.length);

// Arrays.copyOf()
int[] copy = Arrays.copyOf(source, source.length);

// clone() 方法
int[] cloned = source.clone();

2. 数组排序

// 基本类型排序
int[] nums = {5, 2, 9, 1, 5};
Arrays.sort(nums);  // [1, 2, 5, 5, 9]

// 对象数组排序
String[] words = {"banana", "apple", "pear"};
Arrays.sort(words);  // ["apple", "banana", "pear"]

// 自定义排序
Integer[] numbers = {5, 2, 9, 1};
Arrays.sort(numbers, (a, b) -> b - a);  // 降序 [9, 5, 2, 1]

3. 数组与集合转换

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

// 数组转List (返回的List不可修改)
String[] array = {"a", "b", "c"};
List<String> list = Arrays.asList(array);

// List转数组
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(2);
Integer[] numArray = numList.toArray(new Integer[0]);

六、注意事项

数组长度固定：创建后不能改变大小
索引从0开始：有效范围是 0 到 length-1
默认初始化值：
- 数值类型：0 或 0.0
- boolean：false
- 对象类型：null
数组是对象：虽然存储基本类型，但数组本身是对象
多维数组实际上是数组的数组：可以创建不规则数组

七、性能考虑

访问速度快：O(1) 时间复杂度访问任意元素
插入/删除慢：需要移动元素，O(n) 时间复杂度
连续内存：数组元素在内存中是连续存储的
适合场景：元素数量固定、频繁随机访问的情况

数组是 Java 中最基础的数据结构之一，理解其特性和使用方法对编写高效代码非常重要。对于需要动态大小的集合，可以考虑使用 ArrayList 等集合类。