Saving a method as a variable

Question

I am trying to save the method outOfBounds which is called inside the lengthOfColor method more than once to a local variable, so that less processing power is used. I provided the lengthOfColor method in which I want to store the variable, and I also provided the outOfBounds method. As you can see the outOfBounds method is a boolean and I am not sure how to store it with integer parameters.

private Integer[] lengthOfColor(int col, boolean color, int pattern, int row) {
        int x = 0;
        int y = 0;
        if (pattern == 1) {
            // vertical pattern
            y = 1;
        } else if (pattern == 2) {
            // horizontal pattern
            x = 1;
        } else if (pattern == 3) {
            // diagonal slope left pattern
            x = 1;
            y = 1;
        } else {
            // diagonal slope right pattern
            x = 1;
            y = -1;
        }
        // length = how many neighbor slots are of same color
        // possible equals number of slots, that you can play off of.
        // whichSide = left or right if horizontal and top or bottom if vertical.
        int length = 0;
        int possible = 0;
        Integer[] whichSide = new Integer[]{1, -1}; 
        for (int side : whichSide) {
            int i = 1;
            boolean complete = false;
            //while complete is false continue the loop
            while (!complete) {
                //mainX == horizontal pattern distance
                //mainY == vertical pattern distance
                int mainX = x * i * side;
                int mainY = y * i * side;
                //if still inbounds and if the same slot is filled and it matches the color, increment length
                if (!outOfBounds(col, mainX, mainY, row) && getIsFilled(col, mainX, mainY, row) &&
                    checkColor(col, mainX, mainY, row) == color) 
                {
                    length++;
                } 
                //if still inbounds and if the same slot is empty, increment possible number of spots and change complete to true
                else if (!outOfBounds(col, mainX, mainY, row) && !getIsFilled(col, mainX, mainY, row) && 
                           getLowestEmptyIndex(myGame.getColumn(col + mainX)) == getLowestEmptyIndex(myGame.getColumn(col)) + mainY - row) 
                {
                    possible++;
                    complete = true;
                }
                //finish the statement to avoid a infinite loop if neither conditions are met.
                else
                {
                    complete = true;
                }
                // If not complete, then check one slot further.
                i = i + 1;
            }
        }
        return new Integer[] {length, possible};
    }


private boolean outOfBounds(int col, int x , int y, int row) 
    {
        int currentX = col;
        int currentY = getLowestEmptyIndex(myGame.getColumn(col)) - row;
        return currentX + x >= myGame.getColumnCount() || currentY + y >= myGame.getRowCount() || currentX + x < 0 || currentY + y < 0;
    }

Answer 1

I see that mainX and mainY change values so there isn't any real optimization that can be done outside of the for and while loop besides creating a boolean value that holds the result of outOfBounds before the if check is called which would reduce the number of operations you need to do. To be honest, the optimization is so insignificant that it wouldn't really matter but would be good coding practice I suppose (JIT might optimize for you as well depending on your code). More importantly the method reduces the extra lines of code you need to type and does not necessarily mean that there is less computing.

So something like this before any outOfBounds call but inside the while loop,

boolean outOfBounds = outOfBounds(col, mainX, mainY, row);

and change your current if(!outOfBounds(col, mainX, mainY, row) && ....) into if (!outOfBounds && ...)

Also the #1 rule to optimization is to not optimize until you are done with your project and notice a significant performance dip. In which case you would start with the biggest bottleneck until the optimal performance is gained. Of course this does not mean coding in an incorrect way which would of course create unnecessary performance losses. In those cases it would also be wise to consider whether or not you are looking at the problem the right way rather than micro-optimizing.

Here's a snippet of what I would do to micro-optimize the code shown.

private Integer[] lengthOfColor(int col, boolean color, int pattern, int row) { // consider changing Integer[] into
  // int[] if you don't need a boxed integer. It will increase performance
  int x = 0;
  int y = 0;
  // length = how many neighbor slots are of same color
  // possible equals number of slots, that you can play off of.
  // whichSide = left or right if horizontal and top or bottom if vertical.
  int length = 0;
  int possible = 0;
  switch (pattern) { // switch may be a tad faster but insignificant. More importantly it provides clarity.
    case 1:
      y = 1;
      break;
    case 2:
      x = 1;
      break;
    case 3:
      x = 1;
      y = 1;
      break;
    default:
      x = 1;
      y = -1;
      break;
  }
  //int[] whichSide = new int[]{1, -1}; // changed to int[] because you don't need a boxed primitive from what is
  // shown
  // nevermind, this line isn't needed and you will be able to avoid an instantiation.
  for (int i = 1; i != -3; i-=2) {
    int count = 1;
    int mainX; // bring this to a higher scope. (honestly this is micro optimization but a habit of mine if this is
    // can be considered in scope)
    int mainY;
    boolean outOfBounds = false;
    //boolean complete = false; // removed as its unnecessary to break out of the while loop.
    //while complete is false continue the loop
    while (true) {
      //mainX == horizontal pattern distance
      //mainY == vertical pattern distance
      mainX = x * count * i;
      mainY = y * count * i;
      outOfBounds = outOfBounds(col, mainX, mainY, row);
      //if still inbounds and if the same slot is filled and it matches the color, increment length
      if (!outOfBounds && getIsFilled(col, mainX, mainY, row) &&
      checkColor(col, mainX, mainY, row) == color) {
        length++;
      }
      //if still inbounds and if the same slot is empty, increment possible number of spots and change complete to
      // true
      else if (!outOfBounds && !getIsFilled(col, mainX, mainY, row) &&
      getLowestEmptyIndex(myGame.getColumn(col + mainX)) == getLowestEmptyIndex(myGame.getColumn(col)) + mainY -
      row) {
        possible++;
        break;
      }
      //finish the statement to avoid a infinite loop if neither conditions are met.
      else {
        break;
      }
      // If not complete, then check one slot further.
      count++;
    }
  }
  return new Integer[]{length, possible}; // once again consider whether or not you need a boxed integer
}


private boolean outOfBounds(int col, int x, int y, int row) {
  //int currentX = col; this is an unnecessary line
  int currentY = getLowestEmptyIndex(myGame.getColumn(col)) - row;
  return col + x >= myGame.getColumnCount() || currentY + y >= myGame.getRowCount() || col + x < 0 ||
  currentY + y < 0;
}