Java 如何更优雅地实现（位）映射的遍历？

一般来说：如何更有效地实现和使用遍历偏移

假设我们在下面定义了一个位图。我们如何从一个固定像素开始遍历（在本例中收集）所有附近的像素，并最终避免这些8 if语句

// The bitmap 1920x1080px
RGBColor[][] imageMatrix = new RGBColor[1920][1080];

// Collect all nearby pixels that are not white
ArrayList<RGBColor> neighboringPixels = new ArrayList<RGBColor>();

// Width-index of center pixel
int w = 50;
// Height-index of center pixel
int h = 50;

// Initializing offsets for a more elegant check-up...
int[][] offsets = { { -1, -1 }, { 0, -1 }, { 1, -1 },
        { 1, 0 }, { 1, 1 }, { 0, 1 }, { -1, 1 },
        { -1, 0 } };

// But this is what I came up with
// Get top-left pixel
if (!(w - 1 < 0 || w - 1 > 255 || h - 1 < 0 || h - 1 > 255)) {
    neighboringPixels.add(imageMatrix[w - 1][h - 1]);
}
// Get top pixel
if (!(w < 0 || w > 255 || h - 1 < 0 || h - 1 > 255)) {
    neighboringPixels.add(imageMatrix[w][h - 1]);
}
// Get top-right pixel
if (!(w + 1 < 0 || w + 1 > 255 || h - 1 < 0 || h - 1 > 255)) {
    neighboringPixels.add(imageMatrix[w + 1][h - 1]);
}
// Get right pixel
if (!(w + 1 < 0 || w + 1 > 255 || h < 0 || h > 255)) {
    neighboringPixels.add(imageMatrix[w + 1][h]);
}
// Get bottom-right pixel
if (!(w + 1 < 0 || w + 1 > 255 || h + 1 < 0 || h + 1 > 255)) {
    neighboringPixels.add(imageMatrix[w + 1][h + 1]);
}
// Get bottom pixel
if (!(w < 0 || w > 255 || h + 1 < 0 || h + 1 > 255)) {
    neighboringPixels.add(imageMatrix[w][h + 1]);
}
// Get bottom-left pixel
if (!(w - 1 < 0 || w - 1 > 255 || h + 1 < 0 || h + 1 > 255)) {
    neighboringPixels.add(imageMatrix[w - 1][h + 1]);
}
// Get left pixel
if (!(w - 1 < 0 || w - 1 > 255 || h < 0 || h > 255)) {
    neighboringPixels.add(imageMatrix[w - 1][h]);
}

//位图1920x1080px
RGBColor[][]图像矩阵=新RGBColor[1920][1080]；
//收集附近所有非白色的像素
ArrayList NeightringPixels=新的ArrayList（）；
//中心像素宽度指数
int w=50；
//中心像素高度指数
int h=50；
//正在初始化偏移以进行更优雅的检查。。。
int[][]偏移量={{-1，-1}，{0，-1}，{1，-1}，
{ 1, 0 }, { 1, 1 }, { 0, 1 }, { -1, 1 },
{ -1, 0 } };
//但这就是我想到的
//获取左上角像素
if（！（w-1<0 | | w-1>255 | | h-1<0 | | h-1>255））{
添加（imageMatrix[w-1][h-1]）；
}
//获取顶级像素
if（！（w<0 | | w>255 | | h-1<0 | | h-1>255））{
添加（imageMatrix[w][h-1]）；
}
//获取右上角像素
如果（！（w+1<0 | | w+1>255 | | h-1<0 | | h-1>255））{
添加（imageMatrix[w+1][h-1]）；
}
//获得正确的像素
如果（！（w+1<0 | | w+1>255 | | h<0 | | h>255））{
添加（imageMatrix[w+1][h]）；
}
//获取右下角像素
如果（！（w+1<0 | | w+1>255 | | h+1<0 | | h+1>255））{
添加（imageMatrix[w+1][h+1]）；
}
//获取底部像素
如果（！（w<0 | | w>255 | | h+1<0 | | h+1>255））{
添加（imageMatrix[w][h+1]）；
}
//获取左下角像素
如果（！（w-1<0 | | w-1>255 | | h+1<0 | | h+1>255））{
添加（imageMatrix[w-1][h+1]）；
}
//左像素
如果（！（w-1<0 | | w-1>255 | | h<0 | | h>255））{
添加（imageMatrix[w-1][h]）；
}

您正在一个3x3正方形上迭代：

for (int i=w-1; i<w+2; ++i) {
   if (i<0 || i>=255) continue;
   for (int j=h-1; j<h+3; ++j) {
       if (j<0 || j>=255) continue;
       if (i==w && j==h) continue;
       neighboringPixels.add(imageMatrix[i][j]);
   }

for（inti=w-1；i简单地说：

for (int i = -1 ; i <= 1 ; i++) {
    int wi = w + i;
    if (wi >= 0 && wi <= 255) {
        for (int j = -1 ; j <= 1 ; j++) {
            int hj = h + j;
            if (!(i == 0 && j == 0) && hj >= 0 && hj <= 255) {
                neighboringPixels.add(imageMatrix[wj][hj]);
            }
        }
    }
}

for（int i=-1；i=0&&wi在最坏的情况下，当前代码包含32个条件

我得出的代码行的最小解决方案大致如下：

final int minH = Math.max(0, h - 1);
final int maxH = Math.min(255, h + 1);
final int minW = Math.max(0, w - 1);
final int maxW = Math.min(255, w + 1);

for (int i = minH; i <= maxH; i++)
    for (int j = minW; j <= maxW; j++)
        if ((i != h) || (j != w))
            neighboringPixels.add(imageMatrix[i][j]);

final int prevH = h - 1;
final int minW = Math.max(0, w - 1);
final int nextH = h + 1;
final int maxW = Math.min(255, w + 1);

if ((prevH >= 0) && (prevH <= 255))
    for (int i = minW; i <= maxW; i++)
        neighboringPixels.add(imageMatrix[prevH][i]);
if ((h >= 0) && (h <= 255)) {
    if ( (minW != w) && (minW <= 255) )
        neighboringPixels.add(imageMatrix[h][minW]);
    if ( (maxW != w) && (maxW >= 0) )
        neighboringPixels.add(imageMatrix[h][maxW]);
}
if ((nextH >= 0) && (nextH <= 255))
    for (int i = minW; i <= maxW; i++)
        neighboringPixels.add(imageMatrix[nextH][i]);

final int minH=Math.max（0，h-1）；
最终整数最大值=数学最小值（255，h+1）；
final int minW=Math.max（0，w-1）；
最终整数maxW=Math.min（255，w+1）；
对于（int i=minH；我定义为“高效”？你是指速度还是代码行？@Lashane我主要是指代码行。必须有一种方法来避免那些8条if语句，甚至26条if语句，我们应该在三维空间中工作。这几乎是正确的代码，只要更改
if（i==0&&j==0）继续；
使用w/h而不是
0