Java枚举反向查找

Question

So I have this enum that doesn't work as I expected and need some modifications:

public enum MyEnum {

    CODE000("text description comes here"),

    private final String value;

    private static final Map<String, MyEnum> LOOKUP = Maps.uniqueIndex(
            Arrays.asList(MyEnum.values()),
            MyEnum::getValue
    );

    MyEnum(final String value) {
        this.value = value;
    }

    public String getValue() {
        return value;

    }


    public static MyEnum fromStatus(String status) {
        return LOOKUP.get(status);
    }
}

The way it works now is:

MyEnum.fromStatus("text description comes here") and of course I want the other way around:

MyEnum.fromStatus("CODE000") to return me "text description comes here"

Can someone suggest how I can change this ?

Answer 1

What you need is a literal lookup, which you get by calling valueOf :

MyEnum code000 =  MyEnum.valueOf("CODE000");

And then:

String val = code000.getValue();

Please note that an exception will be raised if the string passed to valueOf doesn't resolve to an enum literal in MyEnum .

Answer 2

Your key function ( MyEnum::getValue ) is wrong as it returns the value. It must be MyEnum::name

This will return the enum and not the text description as the value of the map is of type MyEnum . You can get the text value by calling getValue on the enum OR you can store the value in the map instead of the enum

Answer 3

If you want to get an enum value by enum name you can use this function :

public static String fromStatus(String status) {
    MyEnum myEnum = valueOf(status);

    return myEnum.getValue();
}

Answer 4

The answers so far are using the method valueOf . This method will return the enum constant as long as you provide a name of an enum constant. Otherwise an IllegalArgumentException will be thrown.

In your question you're using a lookup map. The Map (it looks like as it's created by Guava Maps ) will return for non-enum-constant-names null . It will not throw a IllegalArgumentException in such cases. So it is a different behaviour.

In addition you say: "and of course I want the other way around"
This means you want to get the enum by status and the status by an enums name.

Therefore you would need to have two lookup methods:

• status -> enum
• name -> status

But you would get a compile time error if you define the two methods you mentioned:

  public static MyEnum fromStatus(String status) { ... }

  public static String fromStatus(String name) { ... }

The compiler could not distinguish the methods by name and parameter. But even though you wrote MyEnum.fromStatus("CODE000") actually it's the enum constant name you are using as parameter. So let's resolve the naming conflict by calling the second method fromName . The code for MyEnum could look like this:

public enum MyEnum {

  CODE000("text description comes here");

  private final String value;

  private static final Map<String, MyEnum> LOOKUP_ENUM = Maps.uniqueIndex(Arrays.asList(MyEnum.values()), MyEnum::getValue);
  private static final Map<String, String> LOOKUP_STATUS = Arrays.stream(MyEnum.values()).collect(Collectors.toMap(MyEnum::name, MyEnum::getValue));

  MyEnum(final String value) {
    this.value = value;
  }

  public String getValue() {
    return value;

  }

  public static MyEnum fromStatus(String status) {
    return LOOKUP_ENUM.get(status);
  }

  public static String fromName(String name) {
    return LOOKUP_STATUS.get(name);
  }

}

If you want to lookup the enum constants by it's names in the same manner (no exception on non-enum-constant-names), you need a third map and a third lookup method:

  private static final Map<String, MyEnum> LOOKUP = Maps.uniqueIndex(Arrays.asList(MyEnum.values()), MyEnum::name);

  public static MyEnum byName(String name) {
    return LOOKUP.get(name);
  }

This would work as follows:

System.out.println(MyEnum.fromStatus("text description comes here")); // CODE000
System.out.println(MyEnum.fromStatus("invalid")); // null - no exception
System.out.println(MyEnum.fromStatus(null)); // null - no exception

System.out.println(MyEnum.fromName("CODE000")); // "text description comes here"
System.out.println(MyEnum.fromName("invalid")); // null - no exception
System.out.println(MyEnum.fromName(null)); // null - no exception

System.out.println(MyEnum.byName("CODE000")); // CODE000
System.out.println(MyEnum.byName("invalid")); // null - no exception
System.out.println(MyEnum.byName(null)); // null - no exception

If you need the byName method I would suggest to rename the method fromName to something like statusByName to keep them comprehensible apart.

Finally one more suggestion:
Since the lookup methods may return null we could return Optional<String> / Optional<MyEnum> as result. This would allow to immediately continue processing the result.

  public static Optional<MyEnum> fromStatus(String status) { ... }
  public static Optional<String> statusByName(String name) { ... }
  public static Optional<MyEnum> byName(String name) { ... }