A final counter in a for loop?

Question

I have this code:

    List r = new ArrayList<>();
    for(int i = 0; i < 10; i++) {
        r.add(new Runnable() {

            @Ove         


        

Answer 1

Looks fine to me. You want to use the value of the loop variable inside your anonymous class and the loop variable obviously can't be final (as its value changes).

Creating a new final local variable is a good solution.

Answer 2

I think your solution is the simplest way.

Another option would be to refactor the creation of the inner class into a factory function that does it for you, then your loop itself could be something clean like:

List<Runnable> r = new ArrayList<>();
for(int i = 0; i < 10; i++) {
    r.add(generateRunnablePrinter(i));
}

And the factory function could just declare a final parameter:

private Runnable generateRunnablePrinter(final int value) {
    return new Runnable() {
       public void run() {
           System.out.println(value);
       }
    };
}

I prefer this refactored approach because it keeps the code cleaner, is relatively self descriptive and also hides away all the inner class plumbing.

Random digression: if you consider anonymous inner classes to be equivalent to closures, then generateRunnablePrinter is effectively a higher order function. Who said you can't do functional programming in Java :-)

Answer 3

(Less-than optimal) alternative: create a small inner class that implements Runnable:

class Printer implements Runnable {
    private int index;

    public Printer(int index) {
        this.index = index;
    }

    public void run() {
        System.out.println(index);
    }
}

List<Runnable> r = new ArrayList<>();
for(int i = 0; i < 10; i++) {
    r.add(new Printer(i));
}

Answer 4

This is what IntelliJ does for you as a fix. The only difference is I would do

ExecutorService es = 
for(int i = 0; i < 10; i++) {
    final int i_final = i;
    es.execute(new Runnable() {

Answer 5

Your solution isn't bad. You could do other stuff, like define your own subclass of Runnable and initialize it with i in the constructor or initialization blocks, but in this case I think it would be just adding complexity without a good cause.

BTW: I assume your example is a syntehetic one, in practice creating a new Runnable just to print an integer wouldn't seem a good idea.

Answer 6

I'm afraid there's no other way than copy your counter to a second final variable and use that in your anonymous inner class. This is one of the "deficiencies" of Java around the topic of closures and an advertised advantage of sibling languages like Groovy.