3 
public enum Gender{

    m("male"), f("female");

    private final String value;

    private Gender(String option){
          value = option;
    }
}

我可以知道如何将字符串“男性”转换为任何枚举吗？是的，该值与枚举不同。这行不通

 Gender.valueOf("male");

我正在考虑提供一个

1）用for循环解析

或者

2）静态初始化一个Map

...

我觉得第二种方式更好，因为当我初始化地图时，如果存在相同的字符串，我可以抛出运行时异常。

有什么优点和缺点，或者还有其他更好的解决方案吗？

4

3 回答 3

5

我会使用地图：

public enum Gender {

    m("male"), f("female");

    private final String value;

    private static final Map<String, Gender> values = new HashMap<String, Gender>();
    static {
        for (Gender g : Gender.values()) {
            if (values.put(g.value, g) != null) {
                  throw new IllegalArgumentException("duplicate value: " + g.value);
            }
        }
    }

    private Gender(String option) {
          value = option;
    }

    public static Gender fromString(String option) {
        return values.get(option);
    }
}

与第一种方法相比，我看到了两个优点：

  1. 此方法可以将字符串转换为Gender时间O(1)，而另一种方法需要O(n)时间。
  2. 这将自动检测重复值。
于 2013-03-07T13:38:47.640 回答
2

这是一个更通用的解决方案。每当枚举映射到代码值时，我都会使用它。当您有一个枚举表示一系列离散值时，它特别有用，这些值映射到一个数据库表。请注意，接下来定义的几个类型只需编写一次，然后就可以在任何枚举上使用。

您首先定义您的枚举（或要存储在集合中的 POJO）将实现的接口：

public interface Coded<T> {
    T getCode();
}

以下利用Google Guava，但是，您可以执行空检查而不是使用它们的Optional类：

public final class CodedFinder {

    private CodedFinder() {}

    public static <V, T extends Enum<T> & Coded<V>> T find(final Class<T> target, final V code) {
        final Optional<T> found = findInternal(Arrays.asList(target.getEnumConstants()), code);
        if (! found.isPresent()) {
            throw new IllegalArgumentException(code.toString() + " is invalid for " + target.getSimpleName());
        }
        return found.get();
    }

    // Additional find methods for arrays and iterables redacted for clarity.

    private static <V, T extends Coded<V>> Optional<T> findInternal(final Iterable<T> values, final V code) {
        return Iterables.tryFind(values, CodedPredicate.of(code));
    }
}

上面的方法使用Class#getEnumConstants来检索枚举中定义的所有值。实际调用的 find 方法不仅可以用于枚举，还可以用于数组和集合等。

我们必须定义一个Predicate来利用Guava 的 find 方法：

public final class CodedPredicate<V, T extends Coded<V>> implements com.google.common.base.Predicate<T> {
    private final V value;

    private CodedPredicate(final V value) {
        this.value = value;
    }

    public static <V, T extends Coded<V>> CodedPredicate<V, T> of(final V value) {
        return new CodedPredicate<V, T>(value);
    }

    public boolean apply(final T current) {
        return value.equals(current.getCode());
    }
}

该谓词是通用的，因此您可以使用Coded<Integer>或任何其他具有合理equals()实现的 POJO。

看起来代码很多，但实际上上面只定义了三种类型，并且可以在任意数量的项目中共享。每当你想搜索一个值时，它变得微不足道：

public final class GenderTest {

    @Test(groups="unit")
    public static void testValid() {

        assert CodedFinder.find(Gender.class, "male")  == Gender.m;
        assert CodedFinder.find(Gender.class, "female") == Gender.f;
    }

    @Test(groups="unit", expectedExceptions=IllegalArgumentException.class)
    public static void testInvalid() {

        CodedFinder.find(Gender.class, "foo");
    }

    public enum Gender implements Coded<String> {

        m("male"), f("female");

        private final String value;

        private Gender(final String option) {
              value = option;
        }

        public String getCode()
        {
            return value;
        }
    }
}
于 2013-03-07T14:06:47.873 回答
0

我遇到过这种情况几次，通常使用您的第一种方法：

public static Gender forValue(String value) {
    for (Gender gender : gender.values()) {
        if (gender.value.equals(value)) {
            return gender;
        }
    }

    return null; // or throw something like IllegalArgumentException 
}

鉴于您value已声明final并且所有实例都需要从代码中声明，您始终对值的唯一性负责，因此对我而言，这个问题几乎不存在。

于 2013-03-07T13:39:48.303 回答