Optimizing if-else /switch-case with string options

Question

What modification would bring to this piece of code? In the last lines, should I use more if-else structures, instead of "if-if-if"

if (action.equals("opt1"))
{
    //something
}
else
{
    if (action.equals("opt2"))
    {
        //something
    }
    else
    {
        if ((action.equals("opt3")) || (action.equals("opt4")))
        {
            //something
        }
        if (action.equals("opt5"))
        {
            //something
        }
        if (action.equals("opt6"))
        {
            //something
        }
    }
}

Later Edit: This is Java. I don't think that switch-case structure will work with Strings.

Later Edit 2:

A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types (discussed in Classes and Inheritance) and a few special classes that "wrap" certain primitive types: Character, Byte, Short, and Integer (discussed in Simple Data Objects ).

Answer 1

Even if you don't use a switch statement, yes, use else if to avoid useless comparison: if the first if is taken, you don't want all others ifs to be evaluated here since they'll always be false. Also you don't need indenting each if making the last block being so indented that you can't see it without scrolling, the following code is perfectly readable:

if (action.equals("opt1")) {
}
else if (action.equals("opt2")) {
}
else if (action.equals("opt3")) {
}
else {
}

Answer 2

Use a dictionary with string as key type and delegates* as value type. - Retrieving the method from using the string will take O(1+load).

Fill the dictionary within the class's constructor.

• Java does not support delegate, so as a work around you may need to define a few inner classes - one for each case and pass the instance of the inner classes instead of the methods as values.

Answer 3

Use a switch statement assuming your language supports switching on a string.

switch(action)
{
   case "opt6":
      //
      break;
   case "opt7":
      //
   ...
   ...
   ...
}

Answer 4

There are a number of ways to do this in Java, but here's a neat one.

enum Option {
    opt1, opt2, opt3, opt4, opt5, opt6
}

...

switch (Option.valueOf(s)) {
case opt1:
    // do opt1
    break;
case opt2:
    // do opt2
    break;
case opt3: case opt4:
    // do opt3 or opt4
    break;
...
}

Note that valueOf(String) will throw an IllegalArgumentException if the argument is not the name of one of the members of the enumeration. Under the hood, the implementation of valueOf uses a static hashmap to map its String argument to an enumeration value.

Answer 5

You can use a switch.

switch (action)
{
 case "opt3":
 case "opt4":
 doSomething;
 break;
 case "opt5":
 doSomething;
 break;
 default:
 doSomeWork;
 break;
}

Answer 6

It depends on your language, but it looks C-like, so you could try a switch statement:

switch(action)
{
case "opt1":
    // something
    break;

case "opt2":
    // something
    break;

case "opt3":
case "opt4":
    // something
    break;

case "opt5":
    // something
    break;

case "opt6":
    // something
    break;
}

However, sometimes switch statements don't provide enough clarity or flexibility (and as Victor noted below, will not work for strings in some languages). Most programming languages will have a way of saying "else if", so rather than writing

if (condition1)
{
    ...
}
else
{
    if (condition2)
    {
        ...
    }
    else
    {
        if (condition3)
        {
            ...
        }
        else
        {
            // This can get very indented very fast
        }
    }
}

...which has a heap of indents, you can write something like this:

if (condition1)
{
    ...
}
else if (condition2)
{
    ...
}
else if (condition3)
{
    ...
}
else
{
    ...
}

In C/C++ and I believe C#, it's else if. In Python, it's elif.

Answer 7

It could help if you specified the language... As it looks like C++, you could use switch.

switch (action) {
   case "opt1":
      // something
      break;
   case "opt2":
      // something
      break;
   ...
}

And in case you want to use if statements, I think you could improve readability and performance a bit if you used "else if" without the curly braces, as in:

if (action.equals("opt1")) {
    //something
} else if (action.equals("opt2")) {
    //something
} else if ((action.equals("opt3")) || (action.equals("opt4"))) {
    //something
} else if (action.equals("opt5")) {
    //something
} else if (action.equals("opt6")) {
    //something
}

I think some compilers can optimize else if better than a else { if. Anyways, I hope I could help!

Answer 8

I would just clean it up as a series of if/else statements:

if(action.equals("opt1"))
{
    // something
}
else if (action.equals("opt2"))
{
    // something
}
else if (action.equals("opt3"))
{
    // something
}
etc...

Answer 9

The answers advising the use of a switch statement are the way to go. A switch statement is much easier to read than the mess of if and if...else statements you have now.

Simple comparisons are fast, and the //something code won't executed for all but one case, so you can skip "optimizing" and go for "maintainability."

Of course, that's assuming that the action.equals() method does something trivial and inexpensive like a ==. If action.equals() is expensive, you've got other problems.

Answer 10

In fact this depends on branch analysis. If 99% of your decisions are "opt1" this code is already pretty good. If 99% of your decisions are "opt6" this code is ugly bad.

If you got often "opt6" and seldom "opt1" put "opt6" in the first comparison and order the following comparisons according to the frequency of the strings in your execution data stream.

If you have a lot of options and all have equal frequency you can sort the options and split them into a form of a binary tree like this:

if (action < "opt20")
{
   if( action < "opt10" )
   {
     if( action  ==  "opt4" ) {...}
     else if( action  ==  "opt2" ) {...}
     else if( action  ==  "opt1" ) {...}
     else if( action  ==  "opt8" ) {...}
   }
}
else
{
    if( action < "opt30 )
    {

    }
    else
    {
      if( action  ==  "opt38" ) {...}
      else if( action  ==  "opt32" ) {...}
    }
}

In this sample the the range splits reduces the needed comparisons for "opt38" and "opt4" to 3. Doing this consequent you get log2(n) +1 comparisons in every branch. this is best for equal frequencies of the options.

Don't do the binary spit to the end, at the end use 4-10 "normal" else if constructs that are ordered by the frequency of the options. The last two or three levels in a binary tree don't take much advance.

Summary

At least there are two optimizations for this kind of comparisons.

1. Binary Decision Trees
2. Ordering due to the frequency of the options

The binary decision tree is used for large switch-case constructs by the compiler. But the compiler don't know anything about frequencies of an option. So the ordering according to the frequencies can be a performance benefit to the use of switch-case if one or two options are much more frequent than others. In this case this is a workaround:

if (action == "opt5") // Processing a frequent (99%) option first
{
}
else // Processing less frequent options (>1%) second
{
    switch( action )
    {
    case "opt1": ...
    case "opt2": ...
    }
}

Warning

Don't optimize your code until you have done profiling and it is really necessary. It is best to use switch-case or else-if straight forward and your code keeps clean and readable. If you have optimized your code, place some good comments in the code so everybody can understand this ugly peace of code. One year later you won't know the profiling data and some comments will be really helpful.

Answer 11

Procedural switching like this very often is better handled by polymorphism - rather than having an action represented by a string, represent an action by an object who has a 'something' method you can specialise. If you find you do need to map a string to the option, use a Map<String,Option>.

If you want to stick to procedural code, and the options in your real code really are all "optX":

if ( action.startsWith("opt") && action.length() == 4 ) {
    switch ( action.charAt(3) ) {
        case '1':  something; break;
        case '2':  something; break;
        case '3':  something; break;
        ...
    }
}

which would be OK in something like a parser ( where breaking strings up is part of the problem domain ), and should be fast, but isn't cohesive ( the connection between the object action and the behaviour is based on the parts of its representation, rather than anything intrinsic in of the object ).

Answer 12

Note that using strings in the cases of a switch statement is one of the new features that will be added in the next version of Java.

See Project Coin: Proposal for Strings in switch

Answer 13

If you find the native java switch construct is too much limiting give a glance to the lambdaj Switcher that allows to declaratively switch on any object by matching them with some hamcrest matchers.