一、数组概述

数组是 Java 中最基本的数据结构之一，具有以下特点：

• 固定长度：一旦创建，长度不可改变
• 连续存储：元素在内存中连续存储
• 类型统一：所有元素必须是相同类型
• 索引访问：通过索引快速访问元素

二、数组定义与初始化

1. 一维数组

// 声明数组
int[] numbers;
String[] names;

// 创建数组
numbers = new int[5];
names = new String[3];

// 声明并创建
int[] scores = new int[10];

// 声明并初始化
int[] values = {1, 2, 3, 4, 5};
String[] fruits = {"苹果", "香蕉", "橙子"};

2. 多维数组

// 二维数组声明
int[][] matrix;

// 创建二维数组
matrix = new int[3][4];

// 声明并创建
int[][] grid = new int[3][3];

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

三、数组常用操作

1. 访问元素

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

// 获取元素
int first = numbers[0];    // 第一个元素
int last = numbers[numbers.length - 1];  // 最后一个元素

// 修改元素
numbers[0] = 10;  // 修改第一个元素

2. 遍历数组

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

// for循环遍历
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// 增强for循环
for (int num : numbers) {
    System.out.println(num);
}

// Stream API遍历
Arrays.stream(numbers).forEach(System.out::println);

3. 数组复制

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

// 使用Arrays.copyOf
int[] copy1 = Arrays.copyOf(source, source.length);

// 使用System.arraycopy
int[] copy2 = new int[source.length];
System.arraycopy(source, 0, copy2, 0, source.length);

// 使用clone方法
int[] copy3 = source.clone();

4. 数组排序

int[] numbers = {5, 2, 8, 1, 9};

// 使用Arrays.sort
Arrays.sort(numbers);

// 使用Stream API排序
int[] sorted = Arrays.stream(numbers)
                     .sorted()
                     .toArray();

5. 数组查找

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

// 线性查找
public static int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

// 二分查找（要求数组已排序）
public static int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

四、数组工具类

1. Arrays类常用方法

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

// 排序
Arrays.sort(numbers);

// 二分查找
int index = Arrays.binarySearch(numbers, 3);

// 填充
Arrays.fill(numbers, 0);  // 所有元素设为0

// 比较
boolean equals = Arrays.equals(numbers, otherArray);

// 转换为字符串
String str = Arrays.toString(numbers);

// 复制
int[] copy = Arrays.copyOf(numbers, numbers.length);

2. 数组转List

// 基本类型数组转List
int[] numbers = {1, 2, 3, 4, 5};
List<Integer> list = Arrays.stream(numbers)
                          .boxed()
                          .collect(Collectors.toList());

// 引用类型数组转List
String[] names = {"Alice", "Bob", "Charlie"};
List<String> nameList = Arrays.asList(names);

五、动态数组

1. ArrayList

// 创建ArrayList
ArrayList<Integer> list = new ArrayList<>();

// 添加元素
list.add(1);
list.add(2);
list.add(3);

// 获取元素
int first = list.get(0);

// 修改元素
list.set(0, 10);

// 删除元素
list.remove(0);  // 按索引删除
list.remove(Integer.valueOf(1));  // 按值删除

// 获取大小
int size = list.size();

2. Vector

// 创建Vector
Vector<Integer> vector = new Vector<>();

// 添加元素
vector.add(1);
vector.add(2);

// 获取元素
int first = vector.get(0);

// 修改元素
vector.set(0, 10);

// 删除元素
vector.remove(0);

六、数组最佳实践

1. 数组初始化

// 推荐：使用Arrays.fill初始化
int[] numbers = new int[5];
Arrays.fill(numbers, 0);

// 推荐：使用循环初始化
for (int i = 0; i < numbers.length; i++) {
    numbers[i] = i;
}

2. 数组扩容

// 创建新数组并复制
public static int[] expandArray(int[] arr, int newSize) {
    int[] newArr = new int[newSize];
    System.arraycopy(arr, 0, newArr, 0, Math.min(arr.length, newSize));
    return newArr;
}

3. 数组判空

// 检查数组是否为空
public static boolean isEmpty(int[] arr) {
    return arr == null || arr.length == 0;
}

数组操作建议

1. 优先使用ArrayList等集合类处理动态数据
2. 注意数组越界问题
3. 合理使用Arrays工具类
4. 考虑使用Stream API简化操作
5. 注意数组的线程安全性
6. 合理选择数组大小