检查Java中是否存在enum

Question

无论如何，是否可以通过将枚举与给定字符串进行比较来检查枚举是否存在？ 我似乎找不到任何这样的功能。 我可以尝试使用 valueOf 方法并捕获异常，但我被告知捕获运行时异常不是一个好的做法。 有人有什么想法吗？

Answer 1

如果我需要这样做，我有时会构建一个 Set 名称，甚至是我自己的 Map - 然后你可以检查一下。

有几点值得注意：

• 在静态初始值设定项中填充任何此类静态集合。 不要使用变量初始值设定项，然后依赖它在枚举构造函数运行时执行 - 它不会这样！ （枚举构造函数是在静态初始化程序之前首先执行的事情。）
• 尽量避免频繁使用 values() - 它每次都必须创建并填充一个新数组。 要迭代所有元素，请使用 EnumSet.allOf 对于没有大量元素的枚举来说效率更高。

示例代码：

import java.util.*;

enum SampleEnum {
    Foo,
    Bar;

    private static final Map<String, SampleEnum> nameToValueMap =
        new HashMap<String, SampleEnum>();
    
    static {
        for (SampleEnum value : EnumSet.allOf(SampleEnum.class)) {
            nameToValueMap.put(value.name(), value);
        }
    }
    
    public static SampleEnum forName(String name) {
        return nameToValueMap.get(name);
    }
}

public class Test {
    public static void main(String [] args)
        throws Exception { // Just for simplicity!
        System.out.println(SampleEnum.forName("Foo"));
        System.out.println(SampleEnum.forName("Bar"));
        System.out.println(SampleEnum.forName("Baz"));
    }
}

当然，如果您只有几个名字，这可能有点过分了——当 n 足够小时，O(n) 解决方案通常会胜过 O(1) 解决方案。 这是另一种方法：

import java.util.*;

enum SampleEnum {
    Foo,
    Bar;

    // We know we'll never mutate this, so we can keep
    // a local copy.
    private static final SampleEnum[] copyOfValues = values();
    
    public static SampleEnum forName(String name) {
        for (SampleEnum value : copyOfValues) {
            if (value.name().equals(name)) {
                return value;
            }
        }
        return null;
    }
}

public class Test {
    public static void main(String [] args)
        throws Exception { // Just for simplicity!
        System.out.println(SampleEnum.forName("Foo"));
        System.out.println(SampleEnum.forName("Bar"));
        System.out.println(SampleEnum.forName("Baz"));
    }
}

Answer 2

我不认为有一种内置的方法可以在不捕获异常的情况下做到这一点。 您可以改为使用如下内容：

public static MyEnum asMyEnum(String str) {
    for (MyEnum me : MyEnum.values()) {
        if (me.name().equalsIgnoreCase(str))
            return me;
    }
    return null;
}

编辑： 正如 Jon Skeet 所指出的，values() 的工作原理是在每次调用时克隆一个私有后备数组。 如果性能至关重要，您可能只想调用 values() 一次，缓存数组，然后迭代它。

此外，如果您的枚举具有大量值，Jon Skeet 的映射替代方案可能比任何数组迭代的性能更好。

Answer 3

我最喜欢的库之一：Apache Commons。

EnumUtils 可以轻松做到这一点。

以下是使用该库验证枚举的示例：

public enum MyEnum {
    DIV("div"), DEPT("dept"), CLASS("class");

    private final String val;

    MyEnum(String val) {
    this.val = val;
    }

    public String getVal() {
    return val;
    }
}


MyEnum strTypeEnum = null;

// test if String str is compatible with the enum 
// e.g. if you pass str = "div", it will return false. If you pass "DIV", it will return true.
if( EnumUtils.isValidEnum(MyEnum.class, str) ){
    strTypeEnum = MyEnum.valueOf(str);
}

Answer 4

我不知道为什么有人告诉你捕获运行时异常是不好的。

使用 valueOf 并捕获 IllegalArgumentException 适合将字符串转换/检查为枚举。

Answer 5

根据 Jon Skeet 的回答，我创建了一个类，可以在工作中轻松完成此操作：

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;

import java.util.EnumSet;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * <p>
 * This permits to easily implement a failsafe implementation of the enums's valueOf
 * Better use it inside the enum so that only one of this object instance exist for each enum...
 * (a cache could solve this if needed)
 * </p>
 *
 * <p>
 * Basic usage exemple on an enum class called MyEnum:
 *
 *   private static final FailSafeValueOf<MyEnum> FAIL_SAFE = FailSafeValueOf.create(MyEnum.class);
 *   public static MyEnum failSafeValueOf(String enumName) {
 *       return FAIL_SAFE.valueOf(enumName);
 *   }
 *
 * </p>
 *
 * <p>
 * You can also use it outside of the enum this way:
 *   FailSafeValueOf.create(MyEnum.class).valueOf("EnumName");
 * </p>
 *
 * @author Sebastien Lorber <i>([email protected])</i>
 */
public class FailSafeValueOf<T extends Enum<T>> {

    private final Map<String,T> nameToEnumMap;

    private FailSafeValueOf(Class<T> enumClass) {
        Map<String,T> map = Maps.newHashMap();
        for ( T value : EnumSet.allOf(enumClass)) {
            map.put( value.name() , value);
        }
        nameToEnumMap = ImmutableMap.copyOf(map);
    }

    /**
     * Returns the value of the given enum element
     * If the 
     * @param enumName
     * @return
     */
    public T valueOf(String enumName) {
        return nameToEnumMap.get(enumName);
    }

    public static <U extends Enum<U>> FailSafeValueOf<U> create(Class<U> enumClass) {
        return new FailSafeValueOf<U>(enumClass);
    }

}

以及单元测试：

import org.testng.annotations.Test;

import static org.testng.Assert.*;


/**
 * @author Sebastien Lorber <i>([email protected])</i>
 */
public class FailSafeValueOfTest {

    private enum MyEnum {
        TOTO,
        TATA,
        ;

        private static final FailSafeValueOf<MyEnum> FAIL_SAFE = FailSafeValueOf.create(MyEnum.class);
        public static MyEnum failSafeValueOf(String enumName) {
            return FAIL_SAFE.valueOf(enumName);
        }
    }

    @Test
    public void testInEnum() {
        assertNotNull( MyEnum.failSafeValueOf("TOTO") );
        assertNotNull( MyEnum.failSafeValueOf("TATA") );
        assertNull( MyEnum.failSafeValueOf("TITI") );
    }

    @Test
    public void testInApp() {
        assertNotNull( FailSafeValueOf.create(MyEnum.class).valueOf("TOTO") );
        assertNotNull( FailSafeValueOf.create(MyEnum.class).valueOf("TATA") );
        assertNull( FailSafeValueOf.create(MyEnum.class).valueOf("TITI") );
    }

}

请注意，我使用 Guava 制作 ImmutableMap 但实际上您可以使用法线贴图，我认为因为贴图永远不会返回...

Answer 6

大多数答案建议使用带有 equals 的循环来检查枚举是否存在，或者使用带有 enum.valueOf() 的 try/catch。 我想知道哪种方法更快并尝试了一下。 我不太擅长基准测试，所以如果我有任何错误，请纠正我。

这是我的主类的代码：

    package enumtest;

public class TestMain {

    static long timeCatch, timeIterate;
    static String checkFor;
    static int corrects;

    public static void main(String[] args) {
        timeCatch = 0;
        timeIterate = 0;
        TestingEnum[] enumVals = TestingEnum.values();
        String[] testingStrings = new String[enumVals.length * 5];
        for (int j = 0; j < 10000; j++) {
            for (int i = 0; i < testingStrings.length; i++) {
                if (i % 5 == 0) {
                    testingStrings[i] = enumVals[i / 5].toString();
                } else {
                    testingStrings[i] = "DOES_NOT_EXIST" + i;
                }
            }

            for (String s : testingStrings) {
                checkFor = s;
                if (tryCatch()) {
                    ++corrects;
                }
                if (iterate()) {
                    ++corrects;
                }
            }
        }

        System.out.println(timeCatch / 1000 + "us for try catch");
        System.out.println(timeIterate / 1000 + "us for iterate");
        System.out.println(corrects);
    }

    static boolean tryCatch() {
        long timeStart, timeEnd;
        timeStart = System.nanoTime();
        try {
            TestingEnum.valueOf(checkFor);
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        } finally {
            timeEnd = System.nanoTime();
            timeCatch += timeEnd - timeStart;
        }

    }

    static boolean iterate() {
        long timeStart, timeEnd;
        timeStart = System.nanoTime();
        TestingEnum[] values = TestingEnum.values();
        for (TestingEnum v : values) {
            if (v.toString().equals(checkFor)) {
                timeEnd = System.nanoTime();
                timeIterate += timeEnd - timeStart;
                return true;
            }
        }
        timeEnd = System.nanoTime();
        timeIterate += timeEnd - timeStart;
        return false;
    }
}

这意味着，每个方法运行枚举长度的 50000 倍
我多次运行此测试，使用 10、20、50 和 100 个枚举常量。
结果如下：

• 10：try/catch：760ms | 迭代：62ms
• 20：尝试/捕获：1671ms | 迭代：177ms
• 50：尝试/捕获：3113ms | 迭代：488ms
• 100：尝试/捕获：6834ms | 迭代：1760ms

这些结果并不准确。 再次执行时，结果有高达 10% 的差异，但它们足以表明，try/catch 方法的效率要低得多，尤其是对于小枚举。

Answer 7

从 Java 8 开始，我们可以使用 流 而不是 for 循环。 另外，返回 Optional 可能是合适的 如果枚举没有具有此类名称的实例。

关于如何查找枚举，我提出了以下三种替代方案：

private enum Test {
    TEST1, TEST2;

    public Test fromNameOrThrowException(String name) {
        return Arrays.stream(values())
                .filter(e -> e.name().equals(name))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("No enum with name " + name));
    }

    public Test fromNameOrNull(String name) {
        return Arrays.stream(values()).filter(e -> e.name().equals(name)).findFirst().orElse(null);
    }

    public Optional<Test> fromName(String name) {
        return Arrays.stream(values()).filter(e -> e.name().equals(name)).findFirst();
    }
}

Answer 8

只需使用 valueOf() 方法即可。

如果该值不存在，它会抛出 IllegalArgumentException 并且您可以像这样 catch 它：

boolean isSettingCodeValid = true;
try {
    SettingCode.valueOf(settingCode.toUpperCase());
} catch (IllegalArgumentException e) {
    // throw custom exception or change the isSettingCodeValid value
    isSettingCodeValid = false;
}

Answer 9

您还可以使用 Guava 并执行以下操作：

// This method returns enum for a given string if it exists, otherwise it returns default enum.
private MyEnum getMyEnum(String enumName) {
  // It is better to return default instance of enum instead of null
  return hasMyEnum(enumName) ? MyEnum.valueOf(enumName) : MyEnum.DEFAULT;
}

// This method checks that enum for a given string exists.
private boolean hasMyEnum(String enumName) {
  return Iterables.any(Arrays.asList(MyEnum.values()), new Predicate<MyEnum>() {
    public boolean apply(MyEnum myEnum) {
      return myEnum.name().equals(enumName);
    }
  }); 
}

在第二种方法中，我使用 guava (Google Guava)库提供了非常有用的Iterables类。 使用 Iterables.any() 方法我们可以检查给定值是否存在于列表对象中。 该方法需要两个参数：一个列表和Predicate对象。 首先，我使用 Arrays.asList() 方法创建一个包含所有枚举的列表。 之后，我创建了新的 Predicate 对象，用于检查给定元素（在我们的例子中为枚举）是否满足 apply 方法中的条件。 如果发生这种情况，方法 Iterables.any() 返回 true 值。

Answer 10

使用 java 8，您可以执行如下操作来检查它是否有效。

Stream.of(MyEnum.values())
        .map(MyEnum::name)
        .collect(Collectors.toList()).contains(<STRING_YOU_WANT_TO_VALIDATE>)

Answer 11

这是我用来检查给定名称的枚举常量是否存在的方法：（

java.util.Arrays.stream(E.values()).map(E::name).toList().contains("");

假设您的枚举称为 E。）在“”内，您应该放置一个枚举常量的名称，您希望检查它是否在枚举与否。
这当然不是最好的解决方案，因为它将数组转换为 Stream，然后再次转换为 List，但它很好，很短，对我来说效果很好。

正如其他人提到的，自从您在 2009 年提出这个问题以来，自 2009 年以来这对您的情况不起作用（除非您迁移到较新版本的 Java）。Java 不支持此答案中使用的功能。 但无论如何我都会发帖，以防使用较新版本 Java 的人想要这样做。