java - 在某些情况下捕获匿名类中开关周围的计数器？

Question

我试图在循环中编写一个开关，在 2/5 的情况下，创建了一个匿名类，它捕获循环计数器。这不是直截了当的，因为计数器需要是最终的才能被匿名内部类捕获。虽然解决方案很简单，只需创建一个 final int i_ 并将其设置为计数器变量。问题是它不起作用(我猜是因为不止一种情况)。这是一段极其简化的代码，它与我的真实代码存在相同的问题:

import java.util.concurrent.*;
import java.util.*;
enum E {A,B,C,D,E}
class A {
    static void s() {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    static Semaphore s = new Semaphore(2); // 2 cores
    public static void main(String[] _){
        LinkedList<E> es = new LinkedList<E>();
        es.push(E.A);
        es.push(E.D);
        es.push(E.B);
        es.push(E.C);
        es.push(E.E);
        es.push(E.C);
        es.push(E.C);
        es.push(E.E);
        es.push(E.A);
        es.push(E.A);
        f(es);
    }
    static void f(List<E> es) {
        int i = 0;
        for (E e : es) {
            s.acquireUninterruptibly();
            switch(e) {
            case A:
                final int i_ = i;
                new Thread() {
                    public void run() {
                        System.out.println("A" + i_); s(); s.release();
                    }
                }.start();
                break;
            case B:
                final int i_ = i;
                new Thread() {
                    public void run() {
                        System.out.println("B" + i_); s(); s.release();
                    }
                }.start();
                break;
            case C:
                new Thread() {
                    public void run() {
                        System.out.println("C"); s(); s.release();
                    }
                }.start();
                break;
            case D:
                new Thread() {
                    public void run() {
                        System.out.println("D"); s(); s.release();
                    }
                }.start();
                break;
            case E:
                new Thread() {
                    public void run() {
                        System.out.println("E"); s(); s.release();
                    }
                }.start();
                break;
            default:
                break;
            }
            i++;
        }
    }
}

它生成线程来完成工作。执行哪些工作由输入列表 es 中的当前元素决定。信号量用于限制当前运行的线程数。

它编译失败，声称 i 已经定义:

$ javac A.java && java A
A.java:27: i_ is already defined in main(java.lang.String[])
                final int i_ = i;
                          ^
1 error

但是它们是在开关的不同情况下定义的。我认为它会起作用，因为你可以对任何其他类型的 block 做同样的事情，例如这个有效:

class A {
    static {
        for (int i = 0; i < 1; i++) {
            int j = i + 1;
        }
        for (int i = 0; i < 1; i++) {
            int j = i + 1;
        }
    }
}

为什么它不能与开关一起使用？还有哪些其他方法可以在多个案例中捕获围绕匿名类内部开关的计数器？

Answer 1

添加大括号:

case A: {
    ...
}
case B: {
    ...
}
...

如您所见，所有 i_ 声明都在同一范围内，这会导致编译错误。在 {} 大括号内嵌套在同一级别的两段代码始终在同一范围内，因此声明在不同的 case 中这一事实没有区别.