Почему я не могу использовать оператор switch в строке?

Операторы переключения с случаями String были реализованы в Java SE 7, по крайней мере, 16 лет после того, как они были впервые запрошены. Явной причины задержки не было указано, но, вероятно, это было связано с производительностью.

Реализация в JDK 7

Эта функция теперь реализована в javac. с процессом "обесахаривания";: чистый высокоуровневый синтаксис с использованием констант String в объявлениях case расширяется во время компиляции в более сложный код, следующий шаблону. Результирующий код использует инструкции JVM, которые существовали всегда.

switch с корпусами String транслируется в два переключателя во время компиляции. Первый отображает каждую строку в уникальное целое число - ее положение в исходном переключателе. Это делается путем первого включения хэш-кода метки. Соответствующий случай - это оператор if, который проверяет равенство строк; если есть коллизии в хэше, тестом является каскадный if-else-if. Второй переключатель отражает это в исходном исходном коде, но заменяет метки case их соответствующими позициями. Этот двухэтапный процесс позволяет легко сохранить управление потоком исходного коммутатора.

Коммутаторы в JVM

Для получения дополнительной технической информации о switch вы можете обратиться к Спецификации JVM, где описывается компиляция операторов переключения. Вкратце, есть две разные инструкции JVM, которые можно использовать для переключения, в зависимости от разреженности констант, используемых в случаях. Оба зависят от использования целочисленных констант для каждого случая для эффективного выполнения.

Если константы плотные, они используются в качестве индекса (после вычитания наименьшего значения) в таблице указателей инструкций - инструкции tableswitch.

Если константы редкие, выполняется двоичный поиск правильного регистра - инструкция lookupswitch.

При снятии сахара с switch на объектах String, вероятно, будут использоваться обе инструкции. lookupswitch подходит для первого включения хэш-кодов, чтобы найти исходное положение корпуса. Полученный порядковый номер естественным образом подходит для tableswitch.

Обе инструкции требуют, чтобы целочисленные константы, присвоенные каждому случаю, были отсортированы во время компиляции. Во время выполнения, хотя производительность O(1) у tableswitch обычно лучше, чем у O(log(n)) у lookupswitch, требуется некоторый анализ, чтобы определить, достаточно ли плотна таблица, чтобы оправдать компромисс между пространством и временем. Билл Веннерс написал отличная статья, который описывает это более подробно, наряду с внутренним взглядом на другие инструкции управления потоком Java.

Перед JDK 7

До JDK 7 enum мог приближаться к коммутатору на основе String. При этом используется метод статический valueOf, сгенерированный компилятором для каждого типа enum. Например:

Pill p = Pill.valueOf(str);
switch(p) {
  case RED:  pop();  break;
  case BLUE: push(); break;
}

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

По этой причине C и C++ допускают переключение только на целочисленные типы, поскольку с другими типами это было бессмысленно.

Разработчики C# решили, что стиль важен, даже если в нем нет преимущества.

Создатели Java, по-видимому, думали, как дизайнеры C.

Если у вас есть место в вашем коде, где вы можете включить String, то может быть лучше реорганизовать String, чтобы он был перечислением возможных значений, которые вы можете включить. Конечно, вы ограничиваете потенциальные значения String, которые вы можете иметь, значениями в перечислении, что может быть, а может и не быть желательным.

Конечно, ваше перечисление может иметь запись для 'other' и метод fromString (String), тогда у вас может быть

ValueEnum enumval = ValueEnum.fromString(myString);
switch (enumval) {
   case MILK: lap(); break;
   case WATER: sip(); break;
   case BEER: quaff(); break;
   case OTHER: 
   default: dance(); break;
}

Джеймс Карран лаконично говорит: «Переключатели, основанные на целых числах, могут быть оптимизированы для получения очень эффективного кода. Переключатели, основанные на другом типе данных, могут быть скомпилированы только в серию операторов if (). По этой причине C и C++ допускают переключение только на целочисленные типы, поскольку с другими типами это было бессмысленно ".

Мое мнение, и только оно, заключается в том, что как только вы начинаете включать непримитивы, вам нужно начать думать о «равных» и «==». Во-первых, сравнение двух строк может быть довольно длительной процедурой, что усугубляет проблемы с производительностью, упомянутые выше. Во-вторых, если есть переключение строк, будет требоваться включение строк без учета регистра, включение строк с учетом / игнорирование языкового стандарта, переключение строк на основе регулярного выражения .... Я бы одобрил решение, которое сэкономило много времени для языковых разработчиков за счет небольшого количества времени для программистов.

Помимо приведенных выше хороших аргументов, я добавлю, что многие люди сегодня видят switch как устаревший остаток процедурного прошлого Java (назад во времена C).

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

Но действительно, стоит посмотреть на случай, когда вам нужен переключатель, и посмотреть, нельзя ли его заменить чем-то более OO. Например, перечисления в Java 1.5+, возможно, HashTable или какая-то другая коллекция (иногда я сожалею, что у нас нет (анонимных) функций в качестве первоклассного гражданина, как в Lua - у которого нет переключателя - или JavaScript) или даже полиморфизма.

Ниже приведен полный пример, основанный на сообщении JeeBee, с использованием перечисления java вместо использования настраиваемого метода.

Обратите внимание, что в Java SE 7 и более поздних версиях вы можете вместо этого использовать объект String в выражении оператора switch.

public class Main {

    /**
    * @param args the command line arguments
    */
    public static void main(String[] args) {

      String current = args[0];
      Days currentDay = Days.valueOf(current.toUpperCase());

      switch (currentDay) {
          case MONDAY:
          case TUESDAY:
          case WEDNESDAY:
              System.out.println("boring");
              break;
          case THURSDAY:
              System.out.println("getting better");
          case FRIDAY:
          case SATURDAY:
          case SUNDAY:
              System.out.println("much better");
              break;

      }
  }

  public enum Days {

    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
  }
}

В Groovy это совсем несложно; Я встраиваю groovy jar и создаю служебный класс groovy, чтобы делать все эти и многие другие вещи, которые мне неприятно делать в Java (поскольку я застрял на Java 6 на предприятии).

it.'p'.each{
switch ([email protected]()){
   case "choclate":
     myholder.myval=(it.text());
     break;
     }}...

В течение многих лет мы использовали для этого препроцессор с открытым исходным кодом.

//#switch(target)
case "foo": code;
//#end

Предварительно обработанные файлы называются Foo.jpp и обрабатываются в Foo.java с помощью ant-скрипта.

Преимущество в том, что он переработан в Java, работающую на 1.0 (хотя обычно мы поддерживали только обратно до 1.4). К тому же это было намного проще (много переключателей строк) по сравнению с подделкой перечислениями или другими обходными путями - код было намного легче читать, поддерживать и понимать. IIRC (на данный момент не может предоставить статистику или технические рассуждения), он также был быстрее, чем естественные эквиваленты Java.

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

Я бы не рекомендовал его для версии 1.7+, но он полезен, если вы хотите запрограммировать Java, ориентированную на более ранние JVM (поскольку Joe public редко устанавливает последнюю версию).

Вы можете получить его из SVN или просмотреть код онлайн. Вам понадобится EBuild, чтобы собрать его как есть.

Также может быть показан пример прямого использования String начиная с версии 1.7:

public static void main(String[] args) {

    switch (args[0]) {
        case "Monday":
        case "Tuesday":
        case "Wednesday":
            System.out.println("boring");
            break;
        case "Thursday":
            System.out.println("getting better");
        case "Friday":
        case "Saturday":
        case "Sunday":
            System.out.println("much better");
            break;
    }

}

Если вы не используете JDK7 или выше, вы можете использовать hashCode() для его моделирования. Поскольку String.hashCode() обычно возвращает разные значения для разных строк и всегда возвращает равные значения для одинаковых строк, он довольно надежен (разные строки может создают тот же хэш-код, что и @Lii, упомянутый в комментарии, например "FB" и "Ea") См. документация.

Итак, код будет выглядеть так:

String s = "<Your String>";

switch(s.hashCode()) {
case "Hello".hashCode(): break;
case "Goodbye".hashCode(): break;
}

Таким образом, вы технически включаете int.

В качестве альтернативы вы можете использовать следующий код:

public final class Switch<T> {
    private final HashMap<T, Runnable> cases = new HashMap<T, Runnable>(0);

    public void addCase(T object, Runnable action) {
        this.cases.put(object, action);
    }

    public void SWITCH(T object) {
        for (T t : this.cases.keySet()) {
            if (object.equals(t)) { // This means that the class works with any object!
                this.cases.get(t).run();
                break;
            }
        }
    }
}

public class StringSwitchCase { 

    public static void main(String args[]) {

        visitIsland("Santorini"); 
        visitIsland("Crete"); 
        visitIsland("Paros"); 

    } 

    public static void visitIsland(String island) {
         switch(island) {
          case "Corfu": 
               System.out.println("User wants to visit Corfu");
               break; 
          case "Crete": 
               System.out.println("User wants to visit Crete");
               break; 
          case "Santorini": 
               System.out.println("User wants to visit Santorini");
               break; 
          case "Mykonos": 
               System.out.println("User wants to visit Mykonos");
               break; 
         default: 
               System.out.println("Unknown Island");
               break; 
         } 
    } 

} 

Когда вы используете intellij, также посмотрите:

Файл -> Структура проекта -> Проект

Файл -> Структура проекта -> Модули

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

В других ответах говорится, что это было добавлено в Java 7 и даны обходные пути для более ранних версий. Этот ответ пытается ответить на вопрос «почему».

Java была реакцией на чрезмерную сложность C++. Он был разработан как простой чистый язык.

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

включение строк довольно сложно, поскольку строки не являются простыми примитивными типами. В то время, когда разрабатывалась Java, это не было распространенной особенностью, и она не очень хорошо вписывалась в минималистичный дизайн. Тем более, что они решили не использовать специальный случай == для строк, было бы (и есть) немного странно, если бы случай работал там, где == не работает.

Между 1.0 и 1.4 сам язык практически не изменился. Большинство усовершенствований Java было сделано на стороне библиотеки.

Все изменилось с выходом Java 5, язык был существенно расширен. Дальнейшие расширения последовали в версиях 7 и 8. Я ожидаю, что это изменение отношения было вызвано появлением C#.

Не очень красиво, но вот другой способ для Java 6 и ниже:

String runFct = 
        queryType.equals("eq") ? "method1":
        queryType.equals("L_L")? "method2":
        queryType.equals("L_R")? "method3":
        queryType.equals("L_LR")? "method4":
            "method5";
Method m = this.getClass().getMethod(runFct);
m.invoke(this);

JEP 354: Switch Expressions (предварительная версия) в JDK-13 и JEP 361: Switch Expressions (Стандарт) в JDK-14 расширяют оператор переключения, поэтому его можно использовать как выражение.

Теперь вы можете:

• напрямую назначить переменную из переключить выражение,
• используйте новую форму метки переключателя (case L ->):

  The code to the right of a "case L ->" switch label is restricted to be an expression, a block, or (for convenience) a throw statement.

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

  To yield a value from a switch expression, the break with value statement is dropped in favor of a yield statement.

Таким образом, демонстрация из ответов (1, 2) может выглядеть так:

  public static void main(String[] args) {
    switch (args[0]) {
      case "Monday", "Tuesday", "Wednesday" ->  System.out.println("boring");
      case "Thursday" -> System.out.println("getting better");
      case "Friday", "Saturday", "Sunday" -> System.out.println("much better");
    }

В Java 11+ это возможно и с переменными. Единственное условие - он должен быть постоянным.

Например:

final String LEFT = "left";
final String RIGHT = "right";
final String UP = "up";
final String DOWN = "down";

String var = ...;

switch (var) {
    case LEFT:
    case RIGHT:
    case DOWN:
    default:
        return 0;
}

PS. Я не пробовал этого с более ранними jdks. Пожалуйста, обновите ответ, если он там тоже поддерживается.

Технические детали были хорошо объяснены в этом отвечать. Я просто хотел добавить, что с Java 12 переключать выражения вы можете сделать это со следующим синтаксисом:

String translation(String cat_language) {
    return switch (cat_language) {
        case "miau miau" -> "I am to run";
        case "miauuuh" -> "I am to sleep";
        case "mi...au?" ->  "leave me alone";
        default ->  "eat";
    };
}