Simplification of successive 'if' statements in Java

Question

I have a series of if statements, as shown below:

if (board[x+1][y]==true) {
    ar+=1;
}
if (board[x][y+1]==true) {
    ar+=1;
}
if (board[x-1][y]==true) {
    ar+=1;
}
if (board[x][y-1]==true) {
    ar+=1;
}
if (board[x+1][y+1]==true) {
    ar+=1;
}
if (board[x+1][y-1]==true) {
    ar+=1;
}
if (board[x-1][y+1]==true) {
    ar+=1;
}
if (board[x-1][y-1]==true) {
    ar+=1;
}

Is there a way to simplify/condense these statements with Java?

Perhaps you are searching for the `switch` statement? Also, are you writing battleship? — Ashwin Gupta, Nov 28 '16 at 04:51
I considered the `switch` statement, but that's only if you're comparing one variable, so I didn't see how I could apply that here. Also, this code is for a visual Conway's Game of Life simulation, but good guess! — Eragon20, Nov 28 '16 at 04:53
@HanletEscaño nope, more than one could be true in which case more than one should be added — Jeremy Kahan, Nov 28 '16 at 04:53
@HanletEscaño That wouldn't work. `ar` needs to increment for **each** time one is `true`. Notice that they aren't `else if` statements. — 4castle, Nov 28 '16 at 04:54
@EugeneRyabtsev Can you add boolean values in Java as though they were integers? I thought you can't. — Ari Brodsky, Nov 28 '16 at 10:23
@SonerGönül In it's current form, it would be closed for lacking context. Code Review is about improving existing, working code. The code posted here is not reviewable in this form because it leaves us guessing at the author's intentions. Unlike Stack Overflow, Code Review needs to look at concrete code in a real context. Please see [Why is hypothetical example code off-topic for CR?](http://meta.codereview.stackexchange.com/q/1709/41243) — Mast, Nov 28 '16 at 10:49
I'd consider separating checking the board contents from enumerating the neighbours. — CodesInChaos, Nov 28 '16 at 13:36

OneCricketeer · Accepted Answer · 2017-11-15T01:02:30.833

42

Simply loop around the position that you care about. Skipping the center of the "box".

Tip: You access a 2D array by row then column, or [y][x] (at least, that's how you'd translate the board from looking at the code).

// int x, y;  // position to look around 
for (int xDiff = -1; xDiff <= 1; xDiff++) {
    for (int yDiff = -1; yDiff <= 1; yDiff++) {
        if (xDiff == 0 && yDiff == 0) continue;
        if (board[y+yDiff][x+xDiff]) { 
            ar += 1;
        }
    }
}

Beware - Out of bounds exception is not handled

edited Nov 15 '17 at 01:02

answered Nov 28 '16 at 04:53

OneCricketeer

179,855
19
132
245

3

As long as they are consistent about `[x][y]` or `[y][x]`, there's really no difference. – 4castle Nov 28 '16 at 04:55
4

True, but clear intention is always good. – OneCricketeer Nov 28 '16 at 04:56
Excellent idea! I appreciate your promptness is responding! – Eragon20 Nov 28 '16 at 04:58
I did this a few time, it even let me expand by changing the 1 in the for loop with a variable called radius. – the_lotus Nov 28 '16 at 15:05
@the_lotus Sure. This could be expanded to `radius` to `-radius`, but the question seemed to be asking about direct neighbors to cell `[x][y]` – OneCricketeer Nov 28 '16 at 16:28
@cricket_007 your answer was perfect, I just wanted to add something for other people that sees it. – the_lotus Nov 28 '16 at 16:34
@the_lotus Gotcha. It would need more work to count all cells between a `radius > 1` and the center, obviously, though. – OneCricketeer Nov 28 '16 at 16:35
@Skizo-ozᴉʞS Please only comment for questions/comments related to *this post* – OneCricketeer Nov 21 '17 at 16:27

score 13 · Answer 2 · answered Nov 28 '16 at 11:07

13

The following would be a more visual equivalent, easily extensible to other shapes of the area of interest. Note ternary operators, ?: which are necessary in Java to convert bools to ints.

ar += (board[x-1][y-1]?1:0) + (board[x-1][y]?1:0) + (board[x-1][y+1]?1:0);
ar += (board[x+0][y-1]?1:0) +                       (board[x+0][y+1]?1:0);
ar += (board[x+1][y-1]?1:0) + (board[x+1][y]?1:0) + (board[x+1][y+1]?1:0);

answered Nov 28 '16 at 11:07

Eugene Ryabtsev

2,232
1
23
37

although this ain't, arguably, the best way to do it (can't extrapolate it easily to bigger board sizes, can be suboptimal in languages where ternaries are evaluated at runtime exclusively etc.), +1 for the freshness of the very idea of grouping them visually depending on coords. – Nov 28 '16 at 16:52
3

Maybe change to a helper function `get(board, x-1, y-1)` so that you don't need to repeat the ternary, and also can add bounds checking easily. – Bergi Nov 28 '16 at 18:05

Eddie Curtis · Answer 3 · 2016-11-28T16:05:32.883

10

In addition to the answers you already have, you can also use enhanced for loops (and re-use the range as it is the same for both).

int[] range = { -1, 0, 1 };
for (int i : range) {
  for (int j : range) {
    if ((i != 0 || j != 0) && board[i][j])  { 
      ar++;
    }
  }
}

edited Nov 28 '16 at 16:05

answered Nov 28 '16 at 09:13

Eddie Curtis

1,207
8
20

You forgot the board[i][j] truth test. I added it in an edit. – Paul Chernoch Nov 28 '16 at 15:57
You're right. Thanks! – Eddie Curtis Nov 28 '16 at 16:04
I always used a for-loop from -1 to 1, never thought about that one... this is cleaner! – AxelH Nov 29 '16 at 06:22

Mikel San Vicente · Answer 4 · 2016-11-28T05:00:56.520

8

This code should give the same result (probably you want to check that you are always in the bounds of the matrix

for(int i=-1; i<=1; i++) {
   for(int j=-1; j<=1; j++) {
        if((i != 0 || j != 0) && board[x+i][y+j]) {
           ar++;
        }
   }
}

edited Nov 28 '16 at 05:00

answered Nov 28 '16 at 04:55

Mikel San Vicente

3,831
2
21
39

score 5 · Answer 5 · answered Nov 28 '16 at 04:55

5

You can simplify as follows as well :

for(int i = x-1;i<=x+1;i++) {
    for(int j=y-1;j<=y+1;j++) { 
        if(i==x && j==y) continue;
        if (board[i][j]) {
           ar+=1;
        }
    }
}

answered Nov 28 '16 at 04:55

Naman

27,789
26
218
353

This can be shortened further to a single line: `for (int i=x-1;i<=x+1;i++) for (int j=y-1;j<=y+1;j++) if ((i!=x || j!=y) && board[i][j]) ar+=1;` – SunKnight0 Nov 28 '16 at 15:46

Adam · Answer 6 · 2017-12-06T09:14:23.047

Looks like you're testing surrounding squares apart from (x, y) itself. I'd use a loop to maintain a counter, with extra step to exclude the (x, y) centre cell.

for (int xTest = x - 1; xTest <= x + 1; xTest++) {
    for (int yTest = y - 1; yTest <= y + 1; yTest++) {
        if (xTest == x && yTest == y) {
            continue;
        }
        if (board[xTest][yTest]) {
            ar += 1;
        }
    }           
}

Also, note the == true is unnecessary. Boolean statements are first class citizens in Java.

Simplification of successive 'if' statements in Java

6 Answers6

Linked