Question

Of course this is an impossible statement in java (to-date), however ideally I would like to implement it as it is at the heart of many iterations. For example the first multiple times it is called I’m doing it 650,000+ times when it is creating the ArrayList.
Unfortunately the reality is that my actual code does not have the set inside the else loop; thus it will pass over both the add and then the set commands and wasting time.

After that I have it also in another loop where it is only performing the set as the data is already created and this is multi-nested with in many others so it is a lengthy process.

ArrayList<Integer>  dataColLinker = new java.util.ArrayList<Integer>();
...
...
public void setLinkerAt( int value, int rowIndex) {
    ...
    while(rowIndex >= dataColLinker.size()) {
        dataColLinker.add(value);
    } else {
        dataColLinker.set(rowIndex, value);
    }

Any ideas or theories?
I’m unsure about speeds in java when it comes to if statements and ArrayList commands and so on

Answer 1

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.