← 返回首页
📦

Java数组详解：一维数组与多维数组

📂 java ⏱ 4 min 790 words
Java数组一维数组多维数组

Java数组详解：一维数组与多维数组

概述

数组是用于存储相同类型元素的容器。Java中的数组是固定长度的，一旦创建就不能改变大小。

1. 一维数组

数组声明

// 方式1：声明并指定大小
int[] numbers = new int[5];

// 方式2：声明并初始化
int[] numbers2 = {1, 2, 3, 4, 5};

// 方式3：声明后初始化
int[] numbers3;
numbers3 = new int[]{1, 2, 3, 4, 5};

数组访问

public class ArrayAccessExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        
        // 访问数组元素
        System.out.println("第一个元素: " + numbers[0]);  // 10
        System.out.println("最后一个元素: " + numbers[numbers.length - 1]);  // 50
        
        // 修改数组元素
        numbers[2] = 35;
        System.out.println("修改后的第三个元素: " + numbers[2]);  // 35
        
        // 获取数组长度
        System.out.println("数组长度: " + numbers.length);  // 5
    }
}

数组遍历

public class ArrayTraversalExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // 方式1：普通for循环
        System.out.print("普通for循环: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + " ");
        }
        System.out.println();
        
        // 方式2：增强for循环
        System.out.print("增强for循环: ");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println();
        
        // 方式3：Arrays.toString()
        System.out.println("Arrays.toString(): " + java.util.Arrays.toString(numbers));
    }
}

数组常用操作

import java.util.Arrays;

public class ArrayOperationsExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9, 3};
        
        // 数组排序
        Arrays.sort(numbers);
        System.out.println("排序后: " + Arrays.toString(numbers));
        
        // 数组复制
        int[] copy = Arrays.copyOf(numbers, numbers.length);
        System.out.println("复制的数组: " + Arrays.toString(copy));
        
        // 数组部分复制
        int[] partialCopy = Arrays.copyOfRange(numbers, 1, 4);
        System.out.println("部分复制: " + Arrays.toString(partialCopy));
        
        // 数组填充
        int[] filled = new int[5];
        Arrays.fill(filled, 10);
        System.out.println("填充后: " + Arrays.toString(filled));
        
        // 数组比较
        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};
        System.out.println("数组相等: " + Arrays.equals(array1, array2));
        
        // 二分查找（数组必须已排序）
        int index = Arrays.binarySearch(numbers, 3);
        System.out.println("元素3的索引: " + index);
    }
}

2. 多维数组

二维数组

public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
        // 声明并初始化二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 访问二维数组
        System.out.println("matrix[0][0] = " + matrix[0][0]);  // 1
        System.out.println("matrix[1][2] = " + matrix[1][2]);  // 6
        
        // 遍历二维数组
        System.out.println("二维数组内容:");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + "\t");
            }
            System.out.println();
        }
        
        // 获取行数和列数
        System.out.println("行数: " + matrix.length);
        System.out.println("列数: " + matrix[0].length);
    }
}

不规则数组

public class JaggedArrayExample {
    public static void main(String[] args) {
        // 不规则数组（每行长度不同）
        int[][] jaggedArray = new int[3][];
        jaggedArray[0] = new int[]{1, 2};
        jaggedArray[1] = new int[]{3, 4, 5};
        jaggedArray[2] = new int[]{6, 7, 8, 9};
        
        // 遍历不规则数组
        for (int i = 0; i < jaggedArray.length; i++) {
            for (int j = 0; j < jaggedArray[i].length; j++) {
                System.out.print(jaggedArray[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

3. 数组作为方法参数

public class ArrayAsParameterExample {
    // 数组作为参数
    public static int sum(int[] numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    // 二维数组作为参数
    public static void printMatrix(int[][] matrix) {
        for (int[] row : matrix) {
            for (int num : row) {
                System.out.print(num + "\t");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        System.out.println("Sum: " + sum(numbers));
        
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };
        System.out.println("Matrix:");
        printMatrix(matrix);
    }
}

4. 数组与字符串转换

public class ArrayStringConversionExample {
    public static void main(String[] args) {
        // 数组转字符串
        int[] numbers = {1, 2, 3, 4, 5};
        String arrayString = java.util.Arrays.toString(numbers);
        System.out.println("数组转字符串: " + arrayString);
        
        // 字符串转数组
        String str = "Hello,World,Java";
        String[] strArray = str.split(",");
        System.out.println("字符串转数组:");
        for (String s : strArray) {
            System.out.println(s);
        }
        
        // 字符数组转字符串
        char[] chars = {'J', 'a', 'v', 'a'};
        String javaString = new String(chars);
        System.out.println("字符数组转字符串: " + javaString);
        
        // 字符串转字符数组
        String text = "Hello";
        char[] charArray = text.toCharArray();
        System.out.println("字符串转字符数组:");
        for (char c : charArray) {
            System.out.println(c);
        }
    }
}

5. 实际应用示例

查找最大值和最小值

public class FindMaxMinExample {
    public static void main(String[] args) {
        int[] numbers = {23, 45, 12, 67, 89, 34, 56};
        
        int max = numbers[0];
        int min = numbers[0];
        
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > max) {
                max = numbers[i];
            }
            if (numbers[i] < min) {
                min = numbers[i];
            }
        }
        
        System.out.println("最大值: " + max);
        System.out.println("最小值: " + min);
    }
}

数组反转

public class ReverseArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        System.out.println("反转前: " + java.util.Arrays.toString(numbers));
        
        // 反转数组
        for (int i = 0; i < numbers.length / 2; i++) {
            int temp = numbers[i];
            numbers[i] = numbers[numbers.length - 1 - i];
            numbers[numbers.length - 1 - i] = temp;
        }
        
        System.out.println("反转后: " + java.util.Arrays.toString(numbers));
    }
}

数组去重

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

public class RemoveDuplicatesExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 2, 4, 3, 5, 1, 6};
        
        System.out.println("去重前: " + Arrays.toString(numbers));
        
        // 使用Set去重
        Set<Integer> set = new LinkedHashSet<>();
        for (int num : numbers) {
            set.add(num);
        }
        
        int[] uniqueNumbers = set.stream().mapToInt(Integer::intValue).toArray();
        System.out.println("去重后: " + Arrays.toString(uniqueNumbers));
    }
}

最佳实践

  1. 使用Arrays类：Java提供了Arrays类来操作数组
  2. 注意数组越界：访问不存在的索引会抛出ArrayIndexOutOfBoundsException
  3. 数组长度固定：如果需要动态大小，使用ArrayList
  4. 使用增强for循环：遍历数组时优先使用增强for循环
  5. 注意多维数组：多维数组的每行长度可能不同

总结

数组是Java中最基本的数据结构之一，掌握数组的使用对于学习其他数据结构和算法非常重要。在实际编程中，要根据需求选择合适的数组操作方法，并注意数组的局限性。