Java: производительность Enums по сравнению с if-then-else

Да, это так, потому что в общем случае оператор switch работает быстрее, чем цепочка if/else.

Хотя сгенерированный байт-код не всегда является окончательным источником для сравнения производительности, вы можете изучить его, чтобы получить лучшее представление.

Например, этот код:

class A { 
    enum N { ONE, TWO, THREE }
    void testSwitch( N e ) { 
        switch( e ) { 
            case ONE : x(); break;
            case TWO : x(); break;
            case THREE : x(); break;
        }
    }
    void testIf( Enum e ) { 
        if( e == N.ONE ) { x(); }
        else if( e == N.TWO ) { x(); }
        else if( e == N.THREE ) { x(); }
    }
    void x(){}
}

Генерирует следующее:

Compiled from "A.java"
class A extends java.lang.Object{
A();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

void testSwitch(A$N);
  Code:
   0:   getstatic   #2; //Field A$1.$SwitchMap$A$N:[I
   3:   aload_1
   4:   invokevirtual   #3; //Method A$N.ordinal:()I
   7:   iaload
   8:   tableswitch{ //1 to 3
        1: 36;
        2: 43;
        3: 50;
        default: 54 }
   36:  aload_0
   37:  invokevirtual   #4; //Method x:()V
   40:  goto    54
   43:  aload_0
   44:  invokevirtual   #4; //Method x:()V
   47:  goto    54
   50:  aload_0
   51:  invokevirtual   #4; //Method x:()V
   54:  return

void testIf(java.lang.Enum);
  Code:
   0:   aload_1
   1:   getstatic   #5; //Field A$N.ONE:LA$N;
   4:   if_acmpne   14
   7:   aload_0
   8:   invokevirtual   #4; //Method x:()V
   11:  goto    39
   14:  aload_1
   15:  getstatic   #6; //Field A$N.TWO:LA$N;
   18:  if_acmpne   28
   21:  aload_0
   22:  invokevirtual   #4; //Method x:()V
   25:  goto    39
   28:  aload_1
   29:  getstatic   #7; //Field A$N.THREE:LA$N;
   32:  if_acmpne   39
   35:  aload_0
   36:  invokevirtual   #4; //Method x:()V
   39:  return

void x();
  Code:
   0:   return

}

Что кажется довольно быстрым в обоих случаях.

Так что выбирайте тот, за которым легче ухаживать.

Просто придерживайтесь наиболее читаемого и понятного кода, который вы можете придумать, я уверен, что вы потеряли все время, выигранное в оптимизации производительности, уже ища этот ответ. Подобные микрооптимизации редко того стоят и могут легко привести к тому, что код станет более сложным, чем необходимо.

Я не знаю о более быстром, я предполагаю, что они оба невероятно быстры.

Я считаю, что переключатель с перечислениями намного читабельнее, чем блок multi-if/else.

Но остерегайтесь пропущенных операторов break!!

Да, оператор switch почти всегда будет выполняться быстрее, чем эквивалентный блок операторов if/else, потому что компилятор может выполнять больше оптимизаций (обычно блок switch компилируется в таблицу ветвлений, что практически невозможно сделать с блоком условности.)

Я бы сказал, что они также более удобочитаемы и удобны в сопровождении (за исключением случаев с провалами, против которых я бы советовал!)

Что касается того, заметно ли это быстрее, это зависит от того, что вы определяете как заметное. Скорее всего, если вы не ищете что-то действительно конкретное, вы вообще этого не заметите, но я бы все равно поступал так из-за преимущества читабельности больше, чем чего-либо еще (рассматривайте преимущество в скорости как бонус!)

Мой ответ на это такой же, как и всегда на вопрос, является ли языковая конструкция X обычно быстрее, чем языковая конструкция Y: общего ответа нет!

Может быть только конкретный ответ для определенных реализаций языка, например. JVM на основе Hotspot-компилятора Oralce (формально Sun) или для IBM JDK на платформе Z, или для OpenJDK в Linux, или...

Таким образом, единственный способ дать осмысленный ответ на ваш вопрос — провести правильный тест. Остерегайтесь микротестов, они чаще ошибочны, чем верны, см., например, Как не стоит писать микротест. Если вы все еще хотите узнать об использовании этого вопроса, используйте структуру, описанную здесь.

Поэтому я бы посоветовал выбирать особенности языка по их применимости и удобочитаемости в вашем контексте.

Теоретически оператор switch может быть оптимизирован как один вычисляемый переход, тогда как цепочки if-then-else должны оставаться отдельными сравнениями. Я не знаю, действительно ли Java выполняет эту оптимизацию.

Несмотря на это, коммутаторы лучше цепочек if-then-else с точки зрения удобочитаемости и ремонтопригодности, поэтому по возможности используйте их в любом случае.