How can I lookup a Java enum from its String value?

Question

I would like to lookup an enum from its string value (or possibly any other value). I've tried the following code but it doesn't allow static in initialisers. Is there a simple way?

public enum Verbosity { BRIEF, NORMAL, FULL; private static Map<String, Verbosity> stringMap = new HashMap<String, Verbosity>(); private Verbosity() { stringMap.put(this.toString(), this); } public static Verbosity getVerbosity(String key) { return stringMap.get(key); } };

IIRC, that gives an NPE because the static initialisation is done top down (i.e. the enum constants at the top are constructed before it gets down to the stringMap initialisation). The usual solution is to use a nested class. — Tom Hawtin - tackline
– Tom Hawtin - tackline, Commented Jul 3, 2009 at 21:36
Thank you everyone for such rapid response. (FWIW I didn't find the Sun Javadocs very useful for this problem). — peter.murray.rust
– peter.murray.rust, Commented Jul 3, 2009 at 21:45
It's really a language issue than a library issue. However, I think the API docs are read more than the JLS (although perhaps not by language designers), so things like this should probably have more prominence in the java.lang docs. — Tom Hawtin - tackline
– Tom Hawtin - tackline, Commented Jul 3, 2009 at 22:37

Brad Mace · Accepted Answer · 2011-04-18 15:00:16Z

293

Use the valueOf method which is automatically created for each Enum.

Verbosity.valueOf("BRIEF") == Verbosity.BRIEF

For arbitrary values start with:

public static Verbosity findByAbbr(String abbr){ for(Verbosity v : values()){ if( v.abbr().equals(abbr)){ return v; } } return null; }

Only move on later to Map implementation if your profiler tells you to.

I know it's iterating over all the values, but with only 3 enum values it's hardly worth any other effort, in fact unless you have a lot of values I wouldn't bother with a Map it'll be fast enough.

edited Apr 18, 2011 at 15:00

Brad Mace

28k19 gold badges110 silver badges152 bronze badges

answered Jul 3, 2009 at 21:34

Gareth Davis

28.1k12 gold badges77 silver badges107 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

peter.murray.rust Over a year ago

thanks - and I can use case conversion if I know the values are still distinct

Amio.io Over a year ago

You can directy access the class member 'abbr' so instead of "v.abbr()" you can use "v.abbr.equals...".

Priidu Neemre Over a year ago

Also, for arbitrary values (the second case) consider throwing an IllegalArgumentException instead of returning null (i.e. when no match is found) - this is how the JDK Enum.valueOf(..) does it, anyway.

Adam Gent Over a year ago

@Gareth Davis I think EnumSet.allOf(Verbosity.class) is probably better than values() which creates a new array on the heap every time!

Gareth Davis Over a year ago

@Adam Gent which in turn will create an object on the heap... doubt very much if you’d ever notice the difference in anything other than insanely sensitive code

|

nbro · Accepted Answer · 2015-05-22 03:39:50Z

174

You're close. For arbitrary values, try something like the following:

public enum Day { MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"), THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ; private final String abbreviation; // Reverse-lookup map for getting a day from an abbreviation private static final Map<String, Day> lookup = new HashMap<String, Day>(); static { for (Day d : Day.values()) { lookup.put(d.getAbbreviation(), d); } } private Day(String abbreviation) { this.abbreviation = abbreviation; } public String getAbbreviation() { return abbreviation; } public static Day get(String abbreviation) { return lookup.get(abbreviation); } }

edited May 22, 2015 at 3:39

nbro

16.1k34 gold badges122 silver badges219 bronze badges

answered Jul 3, 2009 at 21:33

Lyle

3,8333 gold badges28 silver badges26 bronze badges

6 Comments

Adam Gent Over a year ago

Due to classloader issues this method will not work reliable. I do not recommend it and I have seen it fail regularly because the lookup map is not ready before being accessed. You need to put the "lookup" outside of the enum or in another class so that it will load first.

Selena Over a year ago

@Adam Gent: There's a link down below to the JLS where this exact construct is posed as an example. It says that static initialization occurs from top to bottom: docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#d5e12267

Adam Gent Over a year ago

Yes modern java like java 8 has fixed the memory model. That being said hot swap agents like jrebel still get messed up if you embed the initialization because of circular references.

Selena Over a year ago

@Adam Gent: Hmmm. I learn something new every day. [Quietly slinking off to refactor my enums with bootstrap singletons ...] Sorry if this is a stupid question, but is this mostly a problem with static initialization?

cbaldan Over a year ago

I've never seen issues with the static code block not being initialized, but I have only used Java 8 since I started in Java, in 2015. I just did a little benchmark using JMH 1.22 and using a HashMap<> to store the enums proved to be over 40% faster than a foor loop.

|

Lam Le · Accepted Answer · 2017-08-20 05:00:20Z

40

with Java 8 you can achieve with this way:

public static Verbosity findByAbbr(final String abbr){ return Arrays.stream(values()).filter(value -> value.abbr().equals(abbr)).findFirst().orElse(null); }

answered Aug 20, 2017 at 5:00

Lam Le

8298 silver badges14 bronze badges

3 Comments

alexander Over a year ago

I would throw an exception rather than returning null. But it is also depending on the use case

Harry_T Over a year ago

@alexander both null and exception should be catched and solved in the follow-up stream properly, no matter which step should take

Sxc-Dev Over a year ago

Great answer. Returning Optional instead of null would have been better. ``` public static Optional<Verbosity> findByAbbr(final String abbr){ return Arrays.stream(values()) .filter(value -> value.abbr().equals(abbr)).findFirst(); } ```

Adam Gent · Accepted Answer · 2016-06-15 20:27:01Z

@Lyle's answer is rather dangerous and I have seen it not work particularly if you make the enum a static inner class. Instead I have used something like this which will load the BootstrapSingleton maps before the enums.

Edit this should not be a problem any more with modern JVMs (JVM 1.6 or greater) but I do think there are still issues with JRebel but I haven't had a chance to retest it.

Load me first:

 public final class BootstrapSingleton { // Reverse-lookup map for getting a day from an abbreviation public static final Map<String, Day> lookup = new HashMap<String, Day>(); }

Now load it in the enum constructor:

 public enum Day { MONDAY("M"), TUESDAY("T"), WEDNESDAY("W"), THURSDAY("R"), FRIDAY("F"), SATURDAY("Sa"), SUNDAY("Su"), ; private final String abbreviation; private Day(String abbreviation) { this.abbreviation = abbreviation; BootstrapSingleton.lookup.put(abbreviation, this); } public String getAbbreviation() { return abbreviation; } public static Day get(String abbreviation) { return lookup.get(abbreviation); } }

If you have an inner enum you can just define the Map above the enum definition and that (in theory) should get loaded before.

Need to define "dangerous" and why an inner class implementation matters. It is more of a top-to-bottom static definition issue but there is working code in another related answer with link back to this question that uses a static Map on the Enum instance itself with a "get" method from user-defined value to Enum type. stackoverflow.com/questions/604424/lookup-enum-by-string-value
@DarrellTeague the original issue was due to old JVMs (pre 1.6) or other JVMs (IBMs) or hotcode swappers (JRebel). The issue should not happen in modern JVMs so I may just delete my answer.
Good to note that indeed it is possible due to custom compiler implementations and runtime optimizations... the ordering could be resequenced, resulting in an error. However, this would appear to violate the spec.

Fredrik · Accepted Answer · 2009-07-04 05:58:28Z

7

And you can't use valueOf()?

Edit: Btw, there is nothing stopping you from using static { } in an enum.

edited Jul 4, 2009 at 5:58

answered Jul 3, 2009 at 21:31

Fredrik

5,8592 gold badges28 silver badges33 bronze badges

4 Comments

Tom Hawtin - tackline Over a year ago

Or the synthetic valueOf on the enum class, so you don't need to specify the enum class Class.

Fredrik Over a year ago

Of course, it just didn't have a javadoc entry so it was hard to link to.

user1239282 Over a year ago

You can use valueOf() but the name must match identically to that set in the enum declaration. Either of the two lookup methods above can be modified to use .equalsIgnoringCase() and have little more robustness to error.

Fredrik Over a year ago

@leonardo True. If it adds robustness or just fault-tolerance is debatable. In most cases I would say it is the latter and in that case it is better to handle it elsewhere and still use Enum's valueOf().

Chad Befus · Accepted Answer · 2018-06-29 22:14:07Z

In case it helps others, the option I prefer, which is not listed here, uses Guava's Maps functionality:

public enum Vebosity { BRIEF("BRIEF"), NORMAL("NORMAL"), FULL("FULL"); private String value; private Verbosity(final String value) { this.value = value; } public String getValue() { return this.value; } private static ImmutableMap<String, Verbosity> reverseLookup = Maps.uniqueIndex(Arrays.asList(Verbosity.values()), Verbosity::getValue); public static Verbosity fromString(final String id) { return reverseLookup.getOrDefault(id, NORMAL); } }

With the default you can use null, you can throw IllegalArgumentException or your fromString could return an Optional, whatever behavior you prefer.

Adrian · Accepted Answer · 2019-04-16 13:15:42Z

since java 8 you can initialize the map in a single line and without static block

private static Map<String, Verbosity> stringMap = Arrays.stream(values()) .collect(Collectors.toMap(Enum::toString, Function.identity()));

+1 Excellent use of streams, and very concise without sacrificing readability! I had also not seen this use of Function.identity() before, I find it much more textually appealing than e -> e.

hfontanez · Accepted Answer · 2024-06-07 13:15:01Z

public enum EnumRole { ROLE_ANONYMOUS_USER_ROLE ("anonymous user role"), ROLE_INTERNAL ("internal role"); private String roleName; public String getRoleName() { return roleName; } EnumRole(String roleName) { this.roleName = roleName; } public static final EnumRole getByValue(String value){ return Arrays.stream(EnumRole.values()).filter(enumRole -> enumRole.roleName.equals(value)).findFirst().orElse(ROLE_ANONYMOUS_USER_ROLE); } public static void main(String[] args) { System.out.println(getByValue("internal role").roleName); } }

Joey · Accepted Answer · 2013-03-14 07:01:30Z

Perhaps, take a look at this. Its working for me. The purpose of this is to lookup 'RED' with '/red_color'. Declaring a static map and loading the enums into it only once would bring some performance benefits if the enums are many.

public class Mapper { public enum Maps { COLOR_RED("/red_color", "RED"); private final String code; private final String description; private static Map<String, String> mMap; private Maps(String code, String description) { this.code = code; this.description = description; } public String getCode() { return name(); } public String getDescription() { return description; } public String getName() { return name(); } public static String getColorName(String uri) { if (mMap == null) { initializeMapping(); } if (mMap.containsKey(uri)) { return mMap.get(uri); } return null; } private static void initializeMapping() { mMap = new HashMap<String, String>(); for (Maps s : Maps.values()) { mMap.put(s.code, s.description); } } } }

Please put in your opinons.

ScrappyDev · Accepted Answer · 2020-03-19 16:05:13Z

If you want a default value and don't want to build lookup maps, you can create a static method to handle that. This example also handles lookups where the expected name would start with a number.

 public static final Verbosity lookup(String name) { return lookup(name, null); } public static final Verbosity lookup(String name, Verbosity dflt) { if (StringUtils.isBlank(name)) { return dflt; } if (name.matches("^\\d.*")) { name = "_"+name; } try { return Verbosity.valueOf(name); } catch (IllegalArgumentException e) { return dflt; } }

If you need it on a secondary value, you would just build the lookup map first like in some of the other answers.

Vinay Sharma · Accepted Answer · 2016-10-09 18:39:16Z

You can define your Enum as following code :

public enum Verbosity { BRIEF, NORMAL, FULL, ACTION_NOT_VALID; private int value; public int getValue() { return this.value; } public static final Verbosity getVerbosityByValue(int value) { for(Verbosity verbosity : Verbosity.values()) { if(verbosity.getValue() == value) return verbosity ; } return ACTION_NOT_VALID; } @Override public String toString() { return ((Integer)this.getValue()).toString(); } };

See following link for more clarification

Ilya · Accepted Answer · 2013-10-10 15:20:17Z

You can use the Enum::valueOf() function as suggested by Gareth Davis & Brad Mace above, but make sure you handle the IllegalArgumentException that would be thrown if the string used is not present in the enum.

Collectives™ on Stack Overflow

How can I lookup a Java enum from its String value?

12 Answers 12

6 Comments

6 Comments

3 Comments

3 Comments

4 Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

12 Answers 12

6 Comments

6 Comments

3 Comments

3 Comments

4 Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Comments

Linked

Related