Java Enum.valueOf() efficiency when value does not exist

Question

Which would you consider more efficient?

The use of 'WeekDay' is just an example:

public enum WeekDay {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY;
}

Loop through and verify day string first:

public void parseString(String line) {
    String[] tokens = line.split();
    String day = tokens[1]; // day 'should' always be a weekday
    if (isValidWeekDay(day)) {
        WeekDay weekDay = WeekDay.valueOf(day); // won't throw exception
        ...
    } else {
        throw new InvalidWeekDayException(day); // subclass of RuntimeException
    }
}
private boolean isValidWeekDay(String day) {
    for (WeekDay weekDay : WeekDay.values()) {
        if(weekDay.toString().equals(day))
           return true;
    }
    return false;
}

Or since in 99.99% of cases, day will be correct:

public void parseString(String line) {
    String[] tokens = line.split();
    String day = tokens[1]; // day 'should' always be a weekday
    try {
        WeekDay weekDay = WeekDay.valueOf(day); // might throw exception
        ...
    } catch (IllegalArgumentException e) {
        throw new InvalidWeekDayException(day, e);
    }
}

Update:

To clarify, the input string will come from a client application, rather than a user. So in other words, it would be a bug to recieve a non workday in this example.

It may sound like a facetious answer, but I would consider the one that ran fastest when I profiled it to be the most efficient. — Oliver Charlesworth
– Oliver Charlesworth, Commented Aug 23, 2011 at 17:15
Is the String coming from something a user enters, or is it all coming from internally? — DHall
– DHall, Commented Aug 23, 2011 at 17:16
I'd use this instead, if you really are doing an enum of days of week : joda-time.sourceforge.net/field.html#dayOfWeek — NimChimpsky
– NimChimpsky, Commented Aug 23, 2011 at 17:20
Why catch the IllegalArgumentException at all, if it's a programming error? IllegalArgumentException is exactly what I would expect if I asked a utility method to parse illegal data that I passed in. — Mark Peters
– Mark Peters, Commented Aug 23, 2011 at 17:25
@NimChimpsky the manual loop and valueOf are not equivalent. Hence my question. — toolkit
– toolkit, Commented Aug 23, 2011 at 17:35

Robin · Accepted Answer · 2014-10-25 19:11:02Z

As has been commented, you will have to profile to find out for sure. Even in your own parsing approach, you can make it faster by returning the enum when you parse the list.

private WeekDay getValidWeekDay(String day) {
    for (WeekDay weekDay : WeekDay.values()) {
        if(weekDay.toString().equals(day))
           return weekDay;
    }
    return null;
}

Unless this is a time critical piece of an application, I wouldn't worry about it in either case and simply take the most readable approach. I think that would be using the WeekDay.valueOf() method.

If you would rather not have to deal with exceptions, then create a Map of your values within the enum and effectively do the equivalent of valueOf() from a lookup which returns null if it is not found.

public enum WeekDay {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY;

    private static Map<String, WeekDay> valueMap;

    public static WeekDay getValue(String possibleName)
    {
        if (valueMap == null)
        {
            valueMap = new HashMap<String, WeekDay>();
            for(WeedDay day: values())
                valueMap.put(day.toString(), day);
        }
        return valueMap.get(possibleName);

    }
 }

This is effectively what the valueOf() method is doing anyway, except it throws the IllegalArgumentException when it is not found. This approach will simply return null, thus not generating the stacktrace.

Kevin Day · Accepted Answer · 2015-02-13 05:41:00Z

What is the performance concern about the 2nd approach? Catching an exception like that costs almost nothing. Using exceptions for normal control flow is generally a bad idea from a design perspective, the days where this was a performance consideration are long gone. In a debugger, using exceptions as significant control operations will slow things down by a factor of about 10. But this gets optimized by the JIT and there is no measurable impact in production.

These numbers are based on experience with an evaluation I did of the zxing project, which uses exceptions for all sorts of flow control. When I first saw it, I was horrified. I still think it's not the best design, but I did quite a bit of testing and can say with a good bit of confidence that it had no real impact on performance. And this is an algorithm that was using exceptions all over the place for flow control. Your situation, where the exception will only get thrown in highly exceptional circumstances, is a non issue.

Edit: I've had a downvote or two on my answer, and I want to make sure that I'm super clear on what I'm saying: I do not think that it's a good idea to use exceptions for normal control flow. Just because performance is not a good argument for not using exceptions this way doesn't mean that there aren't other, perfectly valid reasons (such as readability, testability, extendability). In the case of the OP, the use of an exception is absolutely called for, and definitely wouldn't cause any sort of performance issue.

aknopov · Accepted Answer · 2015-01-30 15:55:54Z

8

I know its an old post, but I believe following result will be still interesting. I run 10000000 tests to find an element in enum ENUM {FIRST, SECOND, THIRD, FOURTH, LAST} using JDK 1.8. The table below shows time required by simple loop and valueOf().

text     loop   valueOf  ratio
------------------------------
"FIRST"  121    65       186%
"LAST"   188    57       330%
"foo"    155    8958     1.7%

Conclusion - I wouldn't use valueOf() if I expect values not matching enum.

answered Jan 30, 2015 at 15:55

aknopov

3453 silver badges5 bronze badges

2 Comments

Kevin Day Over a year ago

Did your testing focus on the efficiency hit of using the exception then? Or was the difference b/c of some implementation detail in the valueOf() method? Did you run this in a normally running JVM (i.e. not in debug mode) with JIT enabled? And did you warm up the JIT by cranking through a bunch of iterations before you started your timers? When I did my testing with zxing, I saw the type of difference you are showing when I ran tests in debug mode - but once the debugger was out of the way, the performance was pretty much identical.

aknopov Over a year ago

Hey @Kevin. There are many parameters that can affect concrete figures in the table. I was just curious about "cost of exception" in my environment (Oracle JVM 1.6 + 64-bit Win7 + Debug mode). I was so surprised by the result that I decided to publish it. I expected 10-20% ratio in worst case based on my C++ experience.

user207421 · Accepted Answer · 2011-08-24 10:26:09Z

3

If your question is really about the efficiency of searching among 7 item you have already wasted too much time on it. Even the fastest search algorithms yield zero or negative benefits until N > 15 or so, other than the O(1) one.

answered Aug 24, 2011 at 10:26

user207421

312k45 gold badges324 silver badges493 bronze badges

Comments

Dilum Ranatunga · Accepted Answer · 2011-08-23 17:28:16Z

2

Store the valid strings in a HashSet, and decide whether a string is a valid day or not based on Set.contains(...).

The set can be a static final Set, and you can wrap in an unmodifiable for good measure:

private static final Map<String> WEEKDAY_STRINGS;
static {
  HashSet<String> set = new HashSet();
  for (WeekDay d : WeekDay.values()) {
    set.add(d.toString());
  }
  WEEKDAY_STRINGS = Collections.unmodifiableSet(set);
}

answered Aug 23, 2011 at 17:28

Dilum Ranatunga

13.4k3 gold badges43 silver badges53 bronze badges

1 Comment

NimChimpsky Over a year ago

this is overcomplicating the problem imho

NimChimpsky · Accepted Answer · 2011-08-23 17:34:18Z

2

The loop doesn't do anything that calling valueof doesn't, they have the same functionality : checking whether your string is valid enum. What do you think you gain from the first option ?

The second option is best:

 try {
     WeekDay weekDay = WeekDay.valueOf(day); // might throw exception
        ...
    } catch (IllegalArgumentException e) {
        throw new InvalidWeekDayException(day);
    }

answered Aug 23, 2011 at 17:34

NimChimpsky

47.5k62 gold badges202 silver badges320 bronze badges

1 Comment

toolkit Over a year ago

I guess its all down to how common invalid days are. If 50% of days were invalid, then some would consider it very inefficient to throw/catch an exception. However if its only the rare client application bug, then this is definitely the way to go.

Vikram · Accepted Answer · 2011-08-23 17:42:18Z

2

Or you could create a lookup of enum values inside your enum when the class first loads(see static modifier) and validate using get() as shown below:

private String dayName;
private static final Map<String,Weekday> lookup = new HashMap<String, Weekday>();
static{
    for (Weekday day: values()){
        lookup.put(day.dayName, d);
    }
}
public static Weekday get(String _name){
    return lookup.get(_name);
}

Let me know if you need more details

answered Aug 23, 2011 at 17:42

Vikram

4,1828 gold badges47 silver badges71 bronze badges

Collectives™ on Stack Overflow

Java Enum.valueOf() efficiency when value does not exist

7 Answers 7

Comments

Comments

2 Comments

Comments

1 Comment

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

Comments

Comments

2 Comments

Comments

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related