Am I missing something?

Doesn't this hypothetical code

while(rowIndex >= dataColLinker.size()) {
    dataColLinker.add(value);
} else {
    dataColLinker.set(rowIndex, value);
}

mean the same thing as this?

while(rowIndex >= dataColLinker.size()) {
    dataColLinker.add(value);
}
dataColLinker.set(rowIndex, value);

or this?

if (rowIndex >= dataColLinker.size()) {
    do {
        dataColLinker.add(value);
    } while(rowIndex >= dataColLinker.size());
} else {
    dataColLinker.set(rowIndex, value);
}

(The latter makes more sense ... I guess). Either way, it is obvious that you can rewrite the loop so that the "else test" is not repeated inside the loop ... as I have just done.

FWIW, this is most likely a case of premature optimization. That is, you are probably wasting your time optimizing code that doesn't need to be optimized:

• For all you know, the JIT compiler's optimizer may have already moved the code around so that the "else" part is no longer in the loop.

• Even if it hasn't, the chances are that the particular thing you are trying to optimize is not a significant bottleneck ... even if it might be executed 600,000 times.

My advice is to forget this problem for now. Get the program working. When it is working, decide if it runs fast enough. If it doesn't then profile it, and use the profiler output to decide where it is worth spending your time optimizing.

The closest Java equivalent is to explicitly keep track of whether you exited the loop with a break... but you don't actually have a break in your code, so using a while-else was pointless in the first place.

For Java folks (and Python folks) who don't know what Python's while-else does, an else clause on a while loop executes if the loop ends without a break. Another way to think about it is that it executes if the while condition is false, just like with an if statement.

A while-else that actually had a break:

while whatever():
    if whatever_else():
        break
    do_stuff()
else:
    finish_up()

could be translated to

boolean noBreak = true;
while (whatever()) {
    if (whateverElse()) {
        noBreak = false;
        break;
    }
    doStuff();
}
if (noBreak) {
    finishUp();
}

You can do away with the nested for loops and leverage the counter variable.

1. Simply use your counter variable: counter/3 will point to the row and counter%3 will point to the column.

2. counter < 9 will help avoid the while(true) approach, which I don't personally recommend.

Also, your code is allowing invalid number into the array and proceeding to the next position, which is not the intended behaviour as per your post.

    Scanner input = new Scanner(System.in);
    int magic_square[][]=new int[3][3];
    int counter = 0;
    System.out.println("Enter the Magic Number: ");
    while(counter < 9){
      System.out.println("Number "+(counter+1));
      int input_num = input.nextInt();
      if (input_num < 1 || input_num > 9){
         System.out.println("ERROR! Input range is invalid.");
       } else {
          magic_square[counter/3][counter%3] = input_num;
          counter++;
       }
    }