二维数组ArrayIndexOutOfBoundsException问题：如何避免边界相邻位置越界？

Hey there! I totally get how frustrating that ArrayIndexOutOfBoundsException can be when you're trying to check all 8 neighboring positions in a 2D array—boundary elements always seem to trip us up. Let's walk through a few practical, easy-to-implement solutions to fix this once and for all.

1. Explicit Index Validation (Most Common & Flexible) #

The core idea here is simple: before accessing a neighboring position, check if its row and column indices fall within the valid range of the array.

First, define the 8 possible direction offsets (up-left, up, up-right, left, right, down-left, down, down-right). Then, for each neighbor, calculate its index and verify it's not out of bounds before accessing the value.

Here's a code example (using Java, but the logic translates to most languages):

int[][] grid = your2DArray; // Replace with your actual array
int rows = grid.length;
if (rows == 0) return; // Handle empty array case
int cols = grid[0].length;

// Define all 8 direction offsets
int[][] directions = {
    {-1, -1}, {-1, 0}, {-1, 1},
    {0, -1},          {0, 1},
    {1, -1},  {1, 0}, {1, 1}
};

for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        // Iterate through each neighbor direction
        for (int[] dir : directions) {
            int neighborRow = i + dir[0];
            int neighborCol = j + dir[1];
            
            // Check if the neighbor index is valid
            if (neighborRow >= 0 && neighborRow < rows 
                && neighborCol >= 0 && neighborCol < cols) {
                // Safe to access the neighbor now!
                int neighborValue = grid[neighborRow][neighborCol];
                // Do your processing here (e.g., count, sum, compare)
            }
        }
    }
}

2. Pad the Array with Boundary Values #

If you don't want to add index checks everywhere, you can wrap your original array in a "padding layer" of dummy values. This way, every position in the original array has 8 valid neighbors in the padded array, eliminating the need for boundary checks.

For example, if your original array is m x n, create a new (m+2) x (n+2) array. Place the original array in the center, and fill the padding with values that make sense for your use case (e.g., copy the original boundary values, or use a default like 0).

int[][] originalGrid = your2DArray;
int originalRows = originalGrid.length;
if (originalRows == 0) return;
int originalCols = originalGrid[0].length;

// Create padded array with extra rows/columns
int[][] paddedGrid = new int[originalRows + 2][originalCols + 2];

// Copy original array into the center of the padded array
for (int i = 0; i < originalRows; i++) {
    System.arraycopy(originalGrid[i], 0, paddedGrid[i+1], 1, originalCols);
}

// Optional: Pad edges with original boundary values (adjust based on your needs)
// Top edge
System.arraycopy(originalGrid[0], 0, paddedGrid[0], 1, originalCols);
// Bottom edge
System.arraycopy(originalGrid[originalRows-1], 0, paddedGrid[originalRows+1], 1, originalCols);
// Left and right edges
for (int i = 0; i < originalRows; i++) {
    paddedGrid[i+1][0] = originalGrid[i][0];
    paddedGrid[i+1][originalCols+1] = originalGrid[i][originalCols-1];
}
// Corners
paddedGrid[0][0] = originalGrid[0][0];
paddedGrid[0][originalCols+1] = originalGrid[0][originalCols-1];
paddedGrid[originalRows+1][0] = originalGrid[originalRows-1][0];
paddedGrid[originalRows+1][originalCols+1] = originalGrid[originalRows-1][originalCols-1];

// Now iterate over original positions, using padded indices
for (int i = 0; i < originalRows; i++) {
    for (int j = 0; j < originalCols; j++) {
        int paddedI = i + 1;
        int paddedJ = j + 1;
        // Directly access all 8 neighbors without checks!
        int topLeft = paddedGrid[paddedI-1][paddedJ-1];
        int top = paddedGrid[paddedI-1][paddedJ];
        int topRight = paddedGrid[paddedI-1][paddedJ+1];
        int left = paddedGrid[paddedI][paddedJ-1];
        int right = paddedGrid[paddedI][paddedJ+1];
        int bottomLeft = paddedGrid[paddedI+1][paddedJ-1];
        int bottom = paddedGrid[paddedI+1][paddedJ];
        int bottomRight = paddedGrid[paddedI+1][paddedJ+1];
        
        // Process these values as needed
    }
}

3. Wrap Index Checks in a Utility Method #

If you prefer cleaner code, encapsulate the index validation logic into a reusable utility method. This way, you can call it whenever you need to get a neighbor value, without cluttering your main loop with checks.

// Utility method to safely get a neighbor value (returns default if out of bounds)
private static int getSafeNeighbor(int[][] grid, int row, int col, int defaultValue) {
    int rows = grid.length;
    if (rows == 0) return defaultValue;
    int cols = grid[0].length;
    
    if (row >= 0 && row < rows && col >= 0 && col < cols) {
        return grid[row][col];
    }
    return defaultValue;
}

// Usage in your main code
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        // Get each neighbor with the utility method
        int topLeft = getSafeNeighbor(grid, i-1, j-1, 0);
        int top = getSafeNeighbor(grid, i-1, j, 0);
        int topRight = getSafeNeighbor(grid, i-1, j+1, 0);
        int left = getSafeNeighbor(grid, i, j-1, 0);
        int right = getSafeNeighbor(grid, i, j+1, 0);
        int bottomLeft = getSafeNeighbor(grid, i+1, j-1, 0);
        int bottom = getSafeNeighbor(grid, i+1, j, 0);
        int bottomRight = getSafeNeighbor(grid, i+1, j+1, 0);
        
        // Process the values
    }
}

Quick Notes to Keep in Mind #

• If your 2D array is irregular (rows have different lengths), you'll need to check the column bounds against the current row's length instead of a global cols variable.
• Always handle empty arrays first to avoid NullPointerExceptions when accessing grid[0].length.

内容的提问来源于stack exchange，提问作者Óscar73