是否有通过将枚举与给定字符串进行比较来检查枚举是否存在？我似乎找不到任何这样的功能。我可以尝试使用valueOf 方法并捕获异常，但我被告知捕获运行时异常并不是一个好习惯。有人有什么想法吗？
【问题讨论】：
如果我需要这样做，我有时会创建一个 Set<String> 的名称，甚至是我自己的 Map<String,MyEnum> - 然后你可以检查一下。
有几点值得注意：
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"));
}
}
【讨论】：
values() 创建并填充一个新数组？我不记得以前听说过，但大概你有消息来源？
我认为没有一种内置方法可以在不捕获异常的情况下执行此操作。你可以改用这样的东西：
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 的 map 替代方法可能比任何数组迭代执行得更好。
【讨论】：
我最喜欢的库之一：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);
}
【讨论】：
我不知道为什么有人告诉你捕获运行时异常很糟糕。
使用valueOf 并捕获IllegalArgumentException 可以很好地将字符串转换/检查为枚举。
【讨论】：
EnumUtils.isValidEnum 方式让它尽可能“干净”。猜猜EnumUtils.isValidEnum 是如何实现的——当然是捕捉IllegalArgumentException :-)
map.get 也应该抛出异常？有两种不同的方法可能会更干净 - 一种是 throwing ，一种是 not - 但是虽然只有一种方法，但我认为 not throw 会更干净。
order status，理论上枚举将始终匹配字符串。一切都取决于用例，如果你从来没有除了枚举将不匹配字符串，所以它是异常的，它应该引发异常。如果这是一种常见情况，是的，您可能应该在尝试转换之前测试您的字符串是否正确，无论如何在这种情况下，如果您在调用 valueOf 之前测试您的字符串，枚举将不匹配仍然非常例外。
根据 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>(lorber.sebastien@gmail.com)</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>(lorber.sebastien@gmail.com)</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 但实际上您可以使用法线贴图，我认为因为该贴图永远不会返回...
【讨论】：
大多数答案建议要么使用带有等于的循环来检查枚举是否存在，要么使用带有 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 方法的效率要低得多，尤其是在使用小的枚举时。
【讨论】：
从 Java 8 开始，我们可以使用 streams 代替 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();
}
}
【讨论】：
只需使用valueOf() 方法。
如果该值不存在，则抛出IllegalArgumentException，您可以像这样catch：
boolean isSettingCodeValid = true;
try {
SettingCode.valueOf(settingCode.toUpperCase());
} catch (IllegalArgumentException e) {
// throw custom exception or change the isSettingCodeValid value
isSettingCodeValid = false;
}
【讨论】：
您也可以使用 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() 返回真值。
【讨论】：
这是我用来检查具有给定名称的枚举常量是否存在的方法：
java.util.Arrays.stream(E.values()).map(E::name).toList().contains("");
（假设您的枚举名为 E。）在“”中，您应该输入一个枚举常量的名称，您希望检查它是否在枚举中定义。 这当然不是最好的解决方案，因为它将数组转换为 Stream，然后再转换为 List，但它又好又短，对我来说效果很好。
正如其他人所提到的，自从您在 2009 年提出这个问题以来，自 2009 年以来，这在您的情况下将不起作用（除非您迁移到更新版本的 Java）。Java 不支持此答案中使用的功能。但无论如何我都会发布，以防有人使用较新版本的 Java 想要这样做。
【讨论】：