Java语法：将大小写转换为变量？

在java中，这种语法是可能的：

int a = 1;
int i = 0;
i = a == 1 ? 5 : 8;

在这种情况下，我是5，因为a=1

开关大小写是否有类似的语法？ 例如：

int a = 1;
int i = 0;
i = switch (a) {
    case 1: 5; break;
    case 2: 8; break;
}

所以我也会是5，因为a=1？

不

只有这样才有可能：

switch (a) {
    case 1: i = 5; break;
    case 2: i = 8; break;
}

没有

只有这样才有可能：

switch (a) {
    case 1: i = 5; break;
    case 2: i = 8; break;
}

---

不，没有这样的语法，但您可以将switch语句包装到一个方法中，并实现类似的行为：

public int switchMethod (int a)
{
     switch (a) {
        case 1: return 5;
        case 2: return 8;
        default : return 0;
    }
}

...
int i = switchMethod (1);

---

不，没有这样的语法，但您可以将switch语句包装到一个方法中，并实现类似的行为：

public int switchMethod (int a)
{
     switch (a) {
        case 1: return 5;
        case 2: return 8;
        default : return 0;
    }
}

...
int i = switchMethod (1);

---

您也可以使用链式三元语句：

int i = (a == 1) ? 5
      : (a == 2) ? 8
      : 0;

---

您也可以使用链式三元语句：

int i = (a == 1) ? 5
      : (a == 2) ? 8
      : 0;

---

遗憾的是，这种语法不受支持。但您可以用Java 8模拟这种行为：

import java.util.Optional;
import java.util.function.Supplier;

public class Switch {

    @SafeVarargs
    public static <T, U> Optional<U> of(T value, Case<T, U>... cases) {
        for (Case<T, U> c : cases) {
            if (value.equals(c.getTestValue())) {
                return Optional.of(c.getSupplier().get());
            }
        }
        return Optional.empty();
    }

    public static <T, U> Case<T, U> when(T testValue, Supplier<U> supplier) {
        return new Case<T, U>() {
            public T getTestValue() {
                return testValue;
            }

            public Supplier<U> getSupplier() {
                return supplier;
            }
        };
    }

    public interface Case<T, U> {
        Supplier<U> getSupplier();

        T getTestValue();
    }
}

---

当然，您可以根据需要调整代码。

遗憾的是，这种语法不受支持。但您可以用Java 8模拟这种行为：

import java.util.Optional;
import java.util.function.Supplier;

public class Switch {

    @SafeVarargs
    public static <T, U> Optional<U> of(T value, Case<T, U>... cases) {
        for (Case<T, U> c : cases) {
            if (value.equals(c.getTestValue())) {
                return Optional.of(c.getSupplier().get());
            }
        }
        return Optional.empty();
    }

    public static <T, U> Case<T, U> when(T testValue, Supplier<U> supplier) {
        return new Case<T, U>() {
            public T getTestValue() {
                return testValue;
            }

            public Supplier<U> getSupplier() {
                return supplier;
            }
        };
    }

    public interface Case<T, U> {
        Supplier<U> getSupplier();

        T getTestValue();
    }
}

---

当然，您可以根据需要调整代码。

Zoiks。也许这个解决方案有点重磅化，以避免一些

=

操作符？这要看情况而定。您可以更进一步，接近Scala的模式匹配，然后它变得非常有用。我认为

切换

“按原样”是不方便和危险的，即使是我温和的临时实现也避免了一些问题（没有“失败”，必须处理默认情况）；不过，处理默认情况更容易通过确定的赋值来实现。同样，这取决于具体情况

Optional

有几种方法可以处理缺少的值，或者您甚至可以选择“停留”在

Optional

中，以便稍后处理该问题。Zoiks。也许这个解决方案有点重磅化，以避免一些

=

操作符？这要看情况而定。您可以更进一步，接近Scala的模式匹配，然后它变得非常有用。我认为

切换

“按原样”是不方便和危险的，即使是我温和的临时实现也避免了一些问题（没有“失败”，必须处理默认情况）；不过，处理默认情况更容易通过确定的赋值来实现。同样，这取决于具体情况

Optional

有几种方法可以处理缺少的值，或者您甚至可以选择“停留”在

Optional

中，以便稍后处理该问题。