Question

这是我的问题 - 我正在寻找（如果它存在）枚举等效于ArrayList.contains();。

以下是我的代码问题示例：

enum choices {a1, a2, b1, b2};

if(choices.???(a1)}{
//do this
}

现在，我意识到ArrayList Strings将是更好的路线，但我必须通过其他地方的开关/案例运行我的枚举内容。因此我的问题。

假设这样的事情不存在，我怎么能去做呢？

Answer 1

使用Apache commons lang3 lib

 EnumUtils.isValidEnum(MyEnum.class, myValue)

Answer 2

这应该这样做：

public static boolean contains(String test) {

    for (Choice c : Choice.values()) {
        if (c.name().equals(test)) {
            return true;
        }
    }

    return false;
}

这种方式意味着您不必担心以后添加额外的枚举值，它们都会被检查。

编辑：如果枚举非常大，您可以将值粘贴在HashSet中：

public static HashSet<String> getEnums() {

  HashSet<String> values = new HashSet<String>();

  for (Choice c : Choice.values()) {
      values.add(c.name());
  }

  return values;
}

然后你可以这样做：values.contains("your string")返回true或false。

Answer 3

您可以使用Enum.valueOf()

enum Choices{A1, A2, B1, B2};

public class MainClass {
  public static void main(String args[]) {
    Choices day;

    try {
       day = Choices.valueOf("A1");
       //yes
    } catch (IllegalArgumentException ex) {  
        //nope
  }
}

如果您希望检查经常失败，您可能最好使用其他已显示的简单循环 - 如果您的枚举包含许多值，可能是builda HashSet或类似的您的枚举值转换为字符串并查询HashSet。

Answer 4

如果您使用的是Java 1.8，则可以选择Stream + Lambda来实现：

public enum Period {
    DAILY, WEEKLY
};

//This is recommended
Arrays.stream(Period.values()).anyMatch((t) -> t.name().equals("DAILY1"));
//May throw java.lang.IllegalArgumentException
Arrays.stream(Period.values()).anyMatch(Period.valueOf("DAILY")::equals);

Answer 5

Guavas Enums可能是你的朋友

例如这样：

enum MyData {
    ONE,
    TWO
}

@Test
public void test() {

    if (!Enums.getIfPresent(MyData.class, "THREE").isPresent()) {
        System.out.println("THREE is not here");
    }
}

Answer 6

更好：

enum choices {
   a1, a2, b1, b2;

  public static boolean contains(String s)
  {
      for(choices choice:values())
           if (choice.name().equals(s)) 
              return true;
      return false;
  } 

};

Answer 7

这里提到了几个图书馆，但我想念我实际想要的那个：春天！

默认情况下，ObjectUtils#containsConstant不区分大小写，但如果需要，可以是严格的。它的使用方式如下：

if(ObjectUtils.containsConstant(Choices.values(), "SOME_CHOISE", true)){
// do stuff
}

注意：我在这里使用了重载方法来演示如何使用区分大小写的检查。您可以省略布尔值以使用不区分大小写的行为。

但是要注意大型枚举，因为它们不像某些人那样使用Map实现...

作为奖励，它还提供了valueOf的不区分大小写的变体：ObjectUtils#caseInsensitiveValueOf

Answer 8

您可以使用此

YourEnum {A1，A2，B1，B2}

RegWriteBinaryValue(
    HKLM64, 'SYSTEM\CurrentControlSet\services\FIDTPU\Parameters', 'Caldata9',
    #$7c#$17#$17#$01...);

@ wightwulf1944建议更新，以提高解决方案的效率。

Answer 9

几个假设：
1）没有尝试/捕获，因为它是特殊的流量控制
2）＆＃39;包含＆＃39;方法必须快速，因为它通常运行几次 3）空间不受限制（普通解决方案通用）

import java.util.HashSet;
import java.util.Set;

enum Choices {
    a1, a2, b1, b2;

    private static Set<String> _values = new HashSet<>();

    // O(n) - runs once
    static{
        for (Choices choice : Choices.values()) {
            _values.add(choice.name());
        }
    }

    // O(1) - runs several times
    public static boolean contains(String value){
        return _values.contains(value);
    }
}

Answer 10

我认为没有，但你可以这样做：

enum choices {a1, a2, b1, b2};

public static boolean exists(choices choice) {
   for(choice aChoice : choices.values()) {
      if(aChoice == choice) {
         return true;
      }
   }
   return false;
}

编辑：

请查看Richard的版本，因为它更合适，因为除非您将其转换为使用Richards所做的字符串，否则这将无效。

Answer 11

为什么不将Pablo的回复与valueOf（）？

结合起来

public enum Choices
{
    a1, a2, b1, b2;

    public static boolean contains(String s) {
        try {
            Choices.valueOf(s);
            return true;
        } catch (Exception e) {
            return false;
        }
}

Answer 12

如果您正在使用Apache Commons（或愿意这样做），您可以查看：

ArrayUtils.contains(choices.values(), value)

Answer 13

这个对我有用：

Arrays.asList(YourEnum.values()).toString().contains("valueToCheck");

Answer 14

您可以将其作为包含方法：

enum choices {a1, a2, b1, b2};
public boolean contains(String value){
    try{
        EnumSet.allOf(choices.class).contains(Enum.valueOf(choices.class, value));
        return true;
    }catch (Exception e) {
        return false;
    }
}

或者您可以将其与代码块一起使用：

try{
    EnumSet.allOf(choices.class).contains(Enum.valueOf(choices.class, "a1"));
    //do something
}catch (Exception e) {
    //do something else
}

Answer 15

Java Streams提供了一种优雅的方法

Stream.of(MyEnum.values()).anyMatch(v -> v.name().equals(strValue))

返回：如果流中的任何元素与提供的值匹配，则为true，否则为false

Answer 16

此方法可用于检查任何Enum，您可以将其添加到Utils类：

public static <T extends Enum<T>> boolean enumContains(Class<T> enumerator, String value)
{
    for (T c : enumerator.getEnumConstants()) {
        if (c.name().equals(value)) {
            return true;
        }
    }
    return false;
}

以这种方式使用：

boolean isContained = Utils.enumContains(choices.class, "value");

Answer 17

我为此验证创建了下一个类

public class EnumUtils {

    public static boolean isPresent(Enum enumArray[], String name) {
        for (Enum element: enumArray ) {
            if(element.toString().equals(name))
                return true;
        }
        return false;
    }

}

用法示例：

public ArrivalEnum findArrivalEnum(String name) {

    if (!EnumUtils.isPresent(ArrivalEnum.values(), name))
        throw new EnumConstantNotPresentException(ArrivalEnum.class,"Arrival value must be 'FROM_AIRPORT' or 'TO_AIRPORT' ");

    return ArrivalEnum.valueOf(name);
}

Answer 18

使用番石榴它甚至更简单：

boolean isPartOfMyEnum(String myString){

return Lists.newArrayList(MyEnum.values().toString()).contains(myString);

}

Answer 19

如果您想导入 Apache commons lang3，

EnumUtils.isValidEnum 可能是最佳选择。如果不遵循是我将用作替代的通用函数。

private <T extends Enum<T>> boolean enumValueExists(Class<T> enumType, String value) {
    boolean result;
    try {
        Enum.valueOf(enumType, value);
        result = true;
    } catch (IllegalArgumentException e) {
        result = false;
    }
    return result;
}

并按如下方式使用

if (enumValueExists(MyEnum.class, configValue)) {
    // happy code
} else {
    // angry code
}

Answer 20

我会写，

var getAngle = function(x, y){
    const angle = Math.atan2(y, x)/Math.PI*180;
    return (360+Math.round(angle))%360; // corrects for angles between 180 ~ 360
}

// you can plug in the mouse coordinate in this
getAngle(-10,10); // returns 135

Enum＃equals仅适用于对象比较。

Answer 21

您还可以使用：com.google.common.base.Enums

Enums.getIfPresent（varEnum.class，varToLookFor）返回一个可选

Enums.getIfPresent（fooEnum.class，myVariable）.isPresent（）吗？ Enums.getIfPresent（fooEnum.class，myVariable）.get：fooEnum.OTHERS

Answer 22

  Set.of(CustomType.values())
     .contains(customTypevalue)

Answer 23

如果您使用的是Java 8或更高版本，则可以执行以下操作：

boolean isPresent(String testString){
      return Stream.of(Choices.values()).map(Enum::name).collect(Collectors.toSet()).contains(testString);
}

Answer 24

检查值是否存在以及获取枚举值的解决方案：

protected TradeType getEnumType(String tradeType) {
    if (tradeType != null) {
        if (EnumUtils.isValidEnum(TradeType.class, tradeType)) {
            return TradeType.valueOf(tradeType);
        }
    }
    return null;
}

Answer 25

如果您想通过String

查找，可以使用valueOf("a1")

Answer 26

这是一个枚举，那些是常量值，所以如果它在switch语句中它只是做这样的事情：

case: val1
case: val2

另外，为什么你需要知道什么被声明为常量？

Answer 27

com.google.common.collect.Sets.newHashSet(MyEnum.values()).contains("myValue")

Answer 28

这结合了以前方法的所有方法，并且应该具有相同的性能。它可用于任何枚举，内联@Richard H的“编辑”解决方案，并对@bestsss等无效值使用例外。唯一的权衡是需要指定类，但这会将其转化为双线。

import java.util.EnumSet;

public class HelloWorld {

static enum Choices {a1, a2, b1, b2}

public static <E extends Enum<E>> boolean contains(Class<E> _enumClass, String value) {
    try {
        return EnumSet.allOf(_enumClass).contains(Enum.valueOf(_enumClass, value));    
    } catch (Exception e) {
        return false; 
    }
}

public static void main(String[] args) {
    for (String value : new String[] {"a1", "a3", null}) {
        System.out.println(contains(Choices.class, value));
    }
}

}

Answer 29

public boolean contains(Choices value) {
   return EnumSet.allOf(Choices.class).contains(value);
}

Answer 30

enum在Java中非常强大。您可以轻松地在枚举中添加contains方法（就像在类中添加方法一样）：

enum choices {
  a1, a2, b1, b2;

  public boolean contains(String s)
  {
      if (s.equals("a1") || s.equals("a2") || s.equals("b1") || s.equals("b2")) 
         return true;
      return false;
  } 

};

Java：检查枚举是否包含给定的字符串？

30 个答案:

Guavas Enums可能是你的朋友