编程马·菜鸟教程

Appearance

8.4 数组常用操作 ​

数组常用操作概述 ​

在 Java 中，数组是一种基础数据结构，提供了多种常用操作。本章将介绍数组的一些常见操作，包括求最大值、最小值、求和、查找等。

1. 求数组的最大值 ​

算法思路 ​

  1. 假设数组的第一个元素为最大值
  2. 遍历数组，将每个元素与当前最大值比较
  3. 如果当前元素大于最大值，则更新最大值
  4. 遍历结束后，最大值即为数组中的最大元素

示例代码 ​

java
public class FindMaxExample {
    public static void main(String[] args) {
        int[] numbers = {10, 30, 50, 20, 40};
        int max = findMax(numbers);
        System.out.println("Maximum value: " + max);
    }
    
    public static int findMax(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("Array cannot be null or empty");
        }
        
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

2. 求数组的最小值 ​

算法思路 ​

  1. 假设数组的第一个元素为最小值
  2. 遍历数组，将每个元素与当前最小值比较
  3. 如果当前元素小于最小值，则更新最小值
  4. 遍历结束后，最小值即为数组中的最小元素

示例代码 ​

java
public class FindMinExample {
    public static void main(String[] args) {
        int[] numbers = {10, 30, 50, 20, 40};
        int min = findMin(numbers);
        System.out.println("Minimum value: " + min);
    }
    
    public static int findMin(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("Array cannot be null or empty");
        }
        
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }
        return min;
    }
}

3. 求数组的和 ​

算法思路 ​

  1. 初始化一个变量 sum 为 0
  2. 遍历数组，将每个元素加到 sum 中
  3. 遍历结束后，sum 即为数组中所有元素的和

示例代码 ​

java
public class ArraySumExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int sum = calculateSum(numbers);
        System.out.println("Sum: " + sum);
    }
    
    public static int calculateSum(int[] array) {
        if (array == null) {
            throw new IllegalArgumentException("Array cannot be null");
        }
        
        int sum = 0;
        for (int number : array) {
            sum += number;
        }
        return sum;
    }
}

4. 求数组的平均值 ​

算法思路 ​

  1. 计算数组的和
  2. 将和除以数组的长度，得到平均值

示例代码 ​

java
public class ArrayAverageExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        double average = calculateAverage(numbers);
        System.out.println("Average: " + average);
    }
    
    public static double calculateAverage(int[] array) {
        if (array == null || array.length == 0) {
            throw new IllegalArgumentException("Array cannot be null or empty");
        }
        
        int sum = 0;
        for (int number : array) {
            sum += number;
        }
        return (double) sum / array.length;
    }
}

5. 查找数组中的元素 ​

线性查找 ​

算法思路：

  1. 遍历数组，逐个比较元素
  2. 如果找到目标元素，返回其索引
  3. 如果遍历结束仍未找到，返回 -1

示例代码：

java
public class LinearSearchExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int target = 30;
        int index = linearSearch(numbers, target);
        if (index != -1) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found");
        }
    }
    
    public static int linearSearch(int[] array, int target) {
        if (array == null) {
            throw new IllegalArgumentException("Array cannot be null");
        }
        
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                return i;
            }
        }
        return -1;
    }
}

二分查找 ​

算法思路：

  1. 要求数组已排序
  2. 找到数组的中间元素
  3. 如果中间元素等于目标元素，返回其索引
  4. 如果中间元素大于目标元素，在左半部分继续查找
  5. 如果中间元素小于目标元素，在右半部分继续查找
  6. 重复上述过程，直到找到目标元素或确定目标元素不存在

示例代码：

java
public class BinarySearchExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50}; // 已排序
        int target = 30;
        int index = binarySearch(numbers, target);
        if (index != -1) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found");
        }
    }
    
    public static int binarySearch(int[] array, int target) {
        if (array == null) {
            throw new IllegalArgumentException("Array cannot be null");
        }
        
        int left = 0;
        int right = array.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (array[mid] == target) {
                return mid;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }
}

6. 数组排序 ​

冒泡排序 ​

算法思路：

  1. 比较相邻的元素，如果前一个元素大于后一个元素，交换它们
  2. 对每一对相邻元素执行同样的操作，从开始第一对到结尾的最后一对
  3. 每一轮结束后，最大的元素会到达数组的末尾
  4. 重复上述过程，每次比较的元素数量减少 1

示例代码：

java
public class BubbleSortExample {
    public static void main(String[] args) {
        int[] numbers = {50, 20, 40, 10, 30};
        System.out.println("Original array:");
        printArray(numbers);
        
        bubbleSort(numbers);
        
        System.out.println("Sorted array:");
        printArray(numbers);
    }
    
    public static void bubbleSort(int[] array) {
        if (array == null) {
            throw new IllegalArgumentException("Array cannot be null");
        }
        
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
    
    public static void printArray(int[] array) {
        for (int number : array) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

选择排序 ​

算法思路：

  1. 找到数组中最小的元素，将其与第一个元素交换
  2. 在剩余的元素中找到最小的元素，将其与第二个元素交换
  3. 重复上述过程，直到整个数组排序完成

示例代码：

java
public class SelectionSortExample {
    public static void main(String[] args) {
        int[] numbers = {50, 20, 40, 10, 30};
        System.out.println("Original array:");
        printArray(numbers);
        
        selectionSort(numbers);
        
        System.out.println("Sorted array:");
        printArray(numbers);
    }
    
    public static void selectionSort(int[] array) {
        if (array == null) {
            throw new IllegalArgumentException("Array cannot be null");
        }
        
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换元素
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
    }
    
    public static void printArray(int[] array) {
        for (int number : array) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

7. 数组复制 ​

使用循环复制 ​

java
public class ArrayCopyExample {
    public static void main(String[] args) {
        int[] original = {10, 20, 30, 40, 50};
        int[] copy = copyArray(original);
        
        System.out.println("Original array:");
        printArray(original);
        System.out.println("Copied array:");
        printArray(copy);
    }
    
    public static int[] copyArray(int[] array) {
        if (array == null) {
            return null;
        }
        
        int[] copy = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;
    }
    
    public static void printArray(int[] array) {
        for (int number : array) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

使用 System.arraycopy() 方法 ​

java
public class SystemArrayCopyExample {
    public static void main(String[] args) {
        int[] original = {10, 20, 30, 40, 50};
        int[] copy = new int[original.length];
        
        // 使用 System.arraycopy() 方法复制数组
        System.arraycopy(original, 0, copy, 0, original.length);
        
        System.out.println("Original array:");
        printArray(original);
        System.out.println("Copied array:");
        printArray(copy);
    }
    
    public static void printArray(int[] array) {
        for (int number : array) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

8. 数组反转 ​

算法思路 ​

  1. 使用两个指针，一个指向数组的开始，一个指向数组的结束
  2. 交换两个指针指向的元素
  3. 左指针向右移动，右指针向左移动
  4. 重复上述过程，直到左指针超过右指针

示例代码 ​

java
public class ArrayReverseExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        System.out.println("Original array:");
        printArray(numbers);
        
        reverseArray(numbers);
        
        System.out.println("Reversed array:");
        printArray(numbers);
    }
    
    public static void reverseArray(int[] array) {
        if (array == null) {
            throw new IllegalArgumentException("Array cannot be null");
        }
        
        int left = 0;
        int right = array.length - 1;
        
        while (left < right) {
            // 交换元素
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
            
            left++;
            right--;
        }
    }
    
    public static void printArray(int[] array) {
        for (int number : array) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

示例：数组常用操作的综合应用 ​

java
public class ArrayOperationsExample {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 9, 1, 7, 2, 8, 4, 6};
        
        System.out.println("Original array:");
        printArray(numbers);
        
        // 求最大值
        int max = findMax(numbers);
        System.out.println("Maximum value: " + max);
        
        // 求最小值
        int min = findMin(numbers);
        System.out.println("Minimum value: " + min);
        
        // 求和
        int sum = calculateSum(numbers);
        System.out.println("Sum: " + sum);
        
        // 求平均值
        double average = calculateAverage(numbers);
        System.out.println("Average: " + average);
        
        // 查找元素
        int target = 7;
        int index = linearSearch(numbers, target);
        if (index != -1) {
            System.out.println("Element " + target + " found at index: " + index);
        } else {
            System.out.println("Element " + target + " not found");
        }
        
        // 排序
        bubbleSort(numbers);
        System.out.println("Sorted array:");
        printArray(numbers);
        
        // 反转
        reverseArray(numbers);
        System.out.println("Reversed array:");
        printArray(numbers);
    }
    
    // 求最大值
    public static int findMax(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
    
    // 求最小值
    public static int findMin(int[] array) {
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }
        return min;
    }
    
    // 求和
    public static int calculateSum(int[] array) {
        int sum = 0;
        for (int number : array) {
            sum += number;
        }
        return sum;
    }
    
    // 求平均值
    public static double calculateAverage(int[] array) {
        int sum = calculateSum(array);
        return (double) sum / array.length;
    }
    
    // 线性查找
    public static int linearSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                return i;
            }
        }
        return -1;
    }
    
    // 冒泡排序
    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
    
    // 反转数组
    public static void reverseArray(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int temp = array[left];
            array[left] = array[right];
            array[right] = temp;
            left++;
            right--;
        }
    }
    
    // 打印数组
    public static void printArray(int[] array) {
        for (int number : array) {
            System.out.print(number + " ");
        }
        System.out.println();
    }
}

常见问题 ​

1. 数组索引越界 ​

症状：运行时错误：ArrayIndexOutOfBoundsException

解决方案：确保数组索引在有效范围内（0 到 length-1）

2. 空指针异常 ​

症状：运行时错误：NullPointerException

解决方案：在操作数组前，检查数组是否为 null

3. 排序算法选择 ​

症状：对于大型数组，排序速度较慢

解决方案：对于大型数组，选择更高效的排序算法，如快速排序、归并排序等

4. 数组长度为零 ​

症状：在计算平均值等操作时出现除以零的错误

解决方案：在操作数组前，检查数组长度是否为零

总结 ​

数组是 Java 中一种重要的数据结构，提供了多种常用操作，包括：

  • 求最大值和最小值
  • 求和和平均值
  • 查找元素（线性查找和二分查找）
  • 排序（冒泡排序和选择排序）
  • 复制数组
  • 反转数组

掌握这些常用操作，对于处理数组数据非常重要。在使用这些操作时，需要注意数组索引越界、空指针异常等问题，确保代码的健壮性。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建