Why switch is faster than if

Question

I have found lots of books in java saying switch statement is faster than if else statement. But I didnot find antwhere saying why switch is faster than if.

Example

I have a situation i have to choose any one item out of two i can use either of the following way

switch(item){

case BREAD:
     //eat Bread
break;
default:
    //leave the restaurant

}

or using if statement like the following

if(item== BREAD){
//eat Bread
}else{
//leave the restaurant
}

considering item and BREAD is constant int value

In the above example which is faster in action and why?

Answer 1

If you are performing an insane amount of checks like 100+ you may want to consider some abstraction.

You have incoming packets that range from ids 0 through 255. You use maybe 150 of them. You may want to consider something like the below instead of a switch of 150 ids.

Packets[] packets = new Packets[150];

static {
     packets[0] = new Login();
     packets[2] = new Logout();
     packets[3] = new GetMessage();
     packets[7] = new AddFriend();
     packets[9] = new JoinGroupChat(); // etc... not going to finish.
}

static final byte[] INDEX_LIST = { 
  0, 2, 3, 7, 9, // etc... Not going to do it, but this will convert packet id to index.
};

public void handlePacket(IncomingData data)
{
    int id = data.readByte();

    packets[INDEX_LIST[id]].execute(data);
}

I should also point out that index list isn't really needed and would probably slow the code down anyways. It was merely a suggestion so you don't have empty locations. Also not to mention is this situation you're only losing out of 106 indexes. I'm not 100% sure, but I believe each of these are pointing to null anyways so no real memory issues would be present.

Answer 2

A switch statement is not always faster than an if statement. It scales better than a long list of if-else statements as switch can perform a lookup based on all the values. However, for a short condition it won't be any faster and could be slower.

Answer 3

The current JVM has two kinds of switch byte codes: LookupSwitch and TableSwitch.

Each case in a switch statement has an integer offset, if these offsets are contiguous (or mostly contiguous with no large gaps) (case 0: case 1: case 2, etc.), then TableSwitch is used.

If the offsets are spread out with large gaps (case 0: case 400: case 93748:, etc.), then LookupSwitch is used.

The difference, in short, is that TableSwitch is done in constant time because each value within the range of possible values is given a specific byte-code offset. Thus, when you give the statement an offset of 3, it knows to jump ahead 3 to find the correct branch.

Lookup switch uses a binary search to find the correct code branch. This runs in O(log n) time, which is still good, but not the best.

For more information on this, see here: Difference between JVM's LookupSwitch and TableSwitch?

So as far as which one is fastest, use this approach: If you have 3 or more cases whose values are consecutive or nearly consecutive, always use a switch.

If you have 2 cases, use an if statement.

For any other situation, switch is most likely faster, but it's not guaranteed, since the binary-search in LookupSwitch could hit a bad scenario.

Also, keep in mind that the JVM will run JIT optimizations on if statements that will try to place the hottest branch first in the code. This is called "Branch Prediction". For more information on this, see here: https://dzone.com/articles/branch-prediction-in-java

Your experiences may vary. I don't know that the JVM doesn't run a similar optimization on LookupSwitch, but I've learned to trust the JIT optimizations and not try to outsmart the compiler.

Answer 4

Because there are special bytecodes that allow efficient switch statement evaluation when there are a lot of cases.

If implemented with IF-statements you would have a check, a jump to the next clause, a check, a jump to the next clause and so on. With switch the JVM loads the value to compare and iterates through the value table to find a match, which is faster in most cases.

Answer 5

At the bytecode level, subject variable is loaded only once into processor register from a memory address in the structured .class file loaded by Runtime,and this is in a switch statement; whereas in an if-statement, a different jvm instruction is produced by your code-compiling DE, and this requires that each variable be loaded in to registers although same variable is used as in next preceeding if-statement. If you know of coding in assembly language then this would be commonplace; although java compiled coxes are not bytecode, or direct machine code, the conditional concept hereof is still consistent. Well, I tried to avoid deeper technicality upon explaining. I hope I had made the concept clear and demystified. Thank you.