2. 程式人生 > >深入理解Java的switch...case...語句

深入理解Java的switch...case...語句

阿新 • • 發佈：2019-07-13

switch...case...中條件表示式的演進

  • 最早時，只支援int、char、byte、short這樣的整型的基本型別或對應的包裝型別Integer、Character、Byte、Short常量
  • JDK1.5開始支援enum，原理是給列舉值進行了內部的編號，進行編號和列舉值的對映
  • 1.7開始支援String，但不允許為null。（原因可以看後文）

case表示式僅限字面值常量嗎？

case表示式既可以用字面值常量，也可以用final修飾且初始化過的變數。例如以下程式碼可正常編譯並執行：

    public static int test(int i) {
        final int j = 2;
        int result;
        switch (i) {
            case 0:
                result = 0;
                break;
            case j:
                result = 1;
                break;
            case 10:
                result = 4;
                break;
            default:
                result = -1;
        }
        return result;
    }

但是沒有初始化就不行，比如下面的程式碼就無法通過編譯

public class SwitchTest {

    private final int caseJ;

    public int test(int i) {
        int result;
        switch (i) {
            case 0:
                result = 0;
                break;
            case caseJ:
                result = 1;
                break;
            case 10:
                result = 4;
                break;
            default:
                result = -1;
        }
        return result;
    }

    SwitchTest(int caseJ) {
        this.caseJ = caseJ;
    }

    public static void main(String[] args) {
        SwitchTest testJ = new SwitchTest(1);
        System.out.print(testJ.test(2));
    }
}

lookupswitch和tableswitch

下面兩種幾乎一樣的程式碼，會編譯出大相徑庭的位元組碼。

lookupswitch

    public static int test(int i) {

        int result;
        switch (i) {
            case 0:
                result = 0;
                break;
            case 2:
                result = 1;
                break;
            case 10:
                result = 4;
                break;
            default:
                result = -1;
        }
        return result;
    }

對應位元組碼

  public static int test(int);
    Code:
       0: iload_0
       1: lookupswitch  { // 3
                     0: 36
                     2: 41
                    10: 46
               default: 51
          }
      36: iconst_0
      37: istore_1
      38: goto          53
      41: iconst_1
      42: istore_1
      43: goto          53
      46: iconst_4
      47: istore_1
      48: goto          53
      51: iconst_m1
      52: istore_1
      53: iload_1
      54: ireturn

tableswitch

    public static int test(int i) {

        int result;
        switch (i) {
            case 0:
                result = 0;
                break;
            case 2:
                result = 1;
                break;
            case 4:
                result = 4;
                break;
            default:
                result = -1;
        }
        return result;
    }
  public static int test(int);
    Code:
       0: iload_0
       1: tableswitch   { // 0 to 4
                     0: 36
                     1: 51
                     2: 41
                     3: 51
                     4: 46
               default: 51
          }
      36: iconst_0
      37: istore_1
      38: goto          53
      41: iconst_1
      42: istore_1
      43: goto          53
      46: iconst_4
      47: istore_1
      48: goto          53
      51: iconst_m1
      52: istore_1
      53: iload_1
      54: ireturn

兩種位元組碼，最大的區別是執行了不同的指令：lookupswitch和tableswitch。

兩種switch區別

  • tableswitch使用了一個數組，通過下標可以直接定位到要跳轉的行。但是在生成位元組碼時，有的行可能在原始碼中並不存在。通過這種方式可以獲得O(1)的時間複雜度。
  • lookupswitch維護了一個key-value的關係，通過逐個比較索引來查詢匹配的待跳轉的行數。而查詢最好的效能是O(log n)，如二分查詢。
    可見，通過用冗餘的機器碼，tableswitch換取了更好的效能。

但是，在分支比較少的情況下，O(log n)其實並不大。n=2時，log n 約為2.8；即使n=100, log n 約為 6.6，與1仍未達到1個數量級的差距。

何時生成tableswitch？何時生成lookupswitch？

在JDK1.8環境下，通過檢索langtools這個包，可以在langtools/src/share/classes/com/sun/tools/javac/jvm/Gen.java看到以下程式碼：

long table_space_cost = 4 + ((long) hi - lo + 1); // words
long table_time_cost = 3; // comparisons
long lookup_space_cost = 3 + 2 * (long) nlabels;
long lookup_time_cost = nlabels;
int opcode =
     nlabels > 0 && table_space_cost + 3 * table_time_cost <= lookup_space_cost + 3 * lookup_time_cost
                ?
                tableswitch : lookupswitch;

這段程式碼的上下文：

  • hi和lo分別代表值的上下限，是通過遍歷switch...case...每個分支獲取的。
  • nlabels表示switch...case...的分支個數

可以看出，決策的條件綜合考慮了時間複雜度(table_time_cost/lookup_time_cost)和空間複雜度(table_space_cost/lookup_space_cost)，並且時間複雜度的權重是空間複雜度的3倍。

存疑點：

  • 各種幻數沒有解釋取值的原因，比如4、3，應該和具體細節實現有關。
  • lookupswitch的時間複雜度使用的是nlabels而沒有取log n。此處可以看做是近似計算。

switch...case...優於if...else...嗎？

一般來說，更多的限制能帶來更好的效能。
從上文可以看出，無論是tableswitch還是lookupswitch，都有對隨機查詢的優化，而if...else...是沒有的，可以看下面的原始碼和位元組碼。

    public static int test2(int i) {

        int result;
        if(i == 0) {
            result = 0;
        } else if(i == 1) {
            result = 1;
        } else if(i == 4) {
            result = 4;
        } else {
            result = -1;
        }
        return result;
    }
  public static int test2(int);
    Code:
       0: iload_0
       1: ifne          9
       4: iconst_0
       5: istore_1
       6: goto          31
       9: iload_0
      10: iconst_1
      11: if_icmpne     19
      14: iconst_1
      15: istore_1
      16: goto          31
      19: iload_0
      20: iconst_4
      21: if_icmpne     29
      24: iconst_4
      25: istore_1
      26: goto          31
      29: iconst_m1
      30: istore_1
      31: iload_1
      32: ireturn

字串常量的case表示式及位元組碼

舉例如下，這段原始碼有兩個特點：

  1. case "ghi"分支裡是沒有賦值程式碼
  2. case "test"分支和case "test2"分支相同
    public static int testString(String str) {

        int result = -4;
        switch (str) {
            case "abc":
                result = 0;
                break;
            case "def":
                result = 1;
                break;
            case "ghi":
                break;
            case "test":
            case "test2":
                result = 1;
                break;
            default:
                result = -1;
        }
        return result;
    }

對應位元組碼

  public static int testString(java.lang.String);
    Code:
       0: bipush        -4
       2: istore_1
       3: aload_0
       4: astore_2
       5: iconst_m1
       6: istore_3
       7: aload_2
       8: invokevirtual #2                  // Method java/lang/String.hashCode:()I
      11: lookupswitch  { // 5
                 96354: 60
                 99333: 74
                102312: 88
               3556498: 102
             110251488: 116
               default: 127
          }
      60: aload_2
      61: ldc           #3                  // String abc
      63: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      66: ifeq          127
      69: iconst_0
      70: istore_3
      71: goto          127
      74: aload_2
      75: ldc           #5                  // String def
      77: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      80: ifeq          127
      83: iconst_1
      84: istore_3
      85: goto          127
      88: aload_2
      89: ldc           #6                  // String ghi
      91: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      94: ifeq          127
      97: iconst_2
      98: istore_3
      99: goto          127
     102: aload_2
     103: ldc           #7                  // String test
     105: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
     108: ifeq          127
     111: iconst_3
     112: istore_3
     113: goto          127
     116: aload_2
     117: ldc           #8                  // String test2
     119: invokevirtual #4                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
     122: ifeq          127
     125: iconst_4
     126: istore_3
     127: iload_3
     128: tableswitch   { // 0 to 4
                     0: 164
                     1: 169
                     2: 174
                     3: 177
                     4: 177
               default: 182
          }
     164: iconst_0
     165: istore_1
     166: goto          184
     169: iconst_1
     170: istore_1
     171: goto          184
     174: goto          184
     177: iconst_1
     178: istore_1
     179: goto          184
     182: iconst_m1
     183: istore_1
     184: iload_1
     185: ireturn

可以看到與整型常量的不同：

  1. String常量判等，先計算hashCode，在lookupswitch分支中再比較是否真正相等。這也是不支援null的原因，此時hashCode無法計算。
  2. lookupswitch分支中，會給每個分支分配一個新下標值，作為後面的tableswitch的索引。原始碼中的分支語句統一在tableswitch中對應分支執行。

為什麼要再生成一段tableswitch？從位元組碼來看，兩個平行的分支（"test"和"test2"），雖然沒有在tableswitch中用同一個陣列下標，但是使用了同一個跳轉行177，在這種情況下減少了位元組碼冗餘。

列舉的case表示式及位元組碼

樣例程式碼如下

    public static int testEnum(StatusEnum statusEnum) {

        int result;
        switch (statusEnum) {
            case INIT:
                result = 0;
                break;
            case FINISH:
                result = 1;
                break;
            default:
                result = -1;
        }
        return result;
    }

對應位元組碼

  public static int testEnum(com.example.StatusEnum);
    Code:
       0: getstatic     #9                  // Field com/example/SwitchTest$1.$SwitchMap$com$example$core$service$domain$enums$StatusEnum:[I
       3: aload_0
       4: invokevirtual #10                 // Method com/example/core/service/domain/enums/StatusEnum.ordinal:()I
       7: iaload
       8: lookupswitch  { // 2
                     1: 36
                     2: 41
               default: 46
          }
      36: iconst_0
      37: istore_1
      38: goto          48
      41: iconst_1
      42: istore_1
      43: goto          48
      46: iconst_m1
      47: istore_1
      48: iload_1
      49: ireturn

可以看到，使用了列舉的ordinal方法確定序號。

其他

通過檢視位元組碼，可以發現原始碼的break關鍵字，對應的是位元組碼goto到具體行的語句。 如果不用break，那麼對應的位元組碼就會“滑落”到下一行語句，繼續執行。

附1——idea檢視位元組碼方法

Mac下preference->Tools->External Tools，點選+，按如下頁面配置即可。

Windows下需要將上圖填入的javap改為javap.exe。

注意：每次檢視位元組碼前，要確保對應類被重新編譯，才能看到最新版。

附2——JDK7或8下，switch...case...使用字串常量編譯報錯解決方式

這種情況的真實原因是，JDK設定不一致，IDE沒有完全使用預期的編譯器版本。
在IDEA裡可以這樣解決：
Project Settings -> Project 設定專案語言
如果仍未解決，檢查
File -> Project Structure -> Modules, 檢視所有模組是否都是預期的等級。
還有一處也可以看下File -> Settings -> Compiler -> Java Compiler. 這裡可以設定專案及模組的編譯器版本。

備註

文中所有log n均為以2為底n的對數。
本文的寫作契機是參加公司的XX安全學習，提到了switch...case...和if...else...的效能有差異，因此花了一天研究了一番。

參考文件

通過位元組碼分析java中的switch語句
Difference between JVM's LookupSwitch and TableSwitch?
IntelliJ switch statement using Strings error: use -source 7
Intellij idea快速檢視Java類位元組

相關推薦

深入理解switch case

switch case語句是我們程式設計中常用的一個表示式。它的語法如下1： switch (expression) { case value1: // 當 expression 的結果與 value1 匹配時，執行此處語句 [break;] case value

深入理解Java的switch...case...語句

switch...case...中條件表示式的演進 最早時，只支援int、char、byte、short這樣的整型的基本型別或對應的包裝型別Integer、Character、Byte、Short常量 JDK1.5開始支援enum，原理是給列舉值進行了內部的編號，進行編號和列舉值的對映 1.7開始支援Str

switch...case語句的理解案例

switch語句 語法：switch(變數) {                 case 常量值1:        &n

深入理解：Mysql執行SQL語句過程

開發人員基本都知道，我們的資料存在資料庫中（目前最多的是mysql和oracle，由於作者更擅長mysql，所以這裡預設資料庫為mysql），伺服器通過sql語句將查詢資料的請求傳入到mysql資料庫。資料庫拿到sql語句以後。都是進行了哪些操作呢？這裡向大家介紹下我

深入理解SQL語句中常出現的where 1=1

本文主要參考   http://bbs.csdn.net/topics/310082591 和 http://www.jb51.net/article/38062.htm 現在進入正題： 加入wher

switch...case語句的深入學習

這是一段C程式碼： /* $begin switch-c */ int switch_eg(int x) {     int result = x;     switch (x) {     case 100:     result *= 13;     break;    

深入理解Java中的i++、++i語句

在幾乎所有的指令式程式設計語言中，必然都會有i++和++i這種語法。在程式設計啟蒙教材《C語言程式設計》一書中，也專門解釋了這兩條語句的區別。有些語言中i++和++i既可以作為左值又可以作為右值，筆者專門測試了一下，在Java語言中，這兩條語句都只能作為右值，而

深入理解SQL語句執行過程

循環 存儲 files 訪問 complete 不可 要求 arch p s SQL語句執行過程詳解一條sql，plsql的執行到底是怎樣執行的呢？一、SQL語句執行原理：第一步:客戶端把語句發給服務器端執行當我們在客戶端執行 select 語句時,客戶端會把這條 SQL

(轉存 作者未知)深入理解HTML協議

期望 intern 屬於 公告欄 機制 被拒 定向 圖片 工具欄 深入理解HTML協議 http協議學 習系列 1. 基礎概念篇 1.1 介紹 HTTP是Hyper Text Transfer Protocol（超文本傳輸協議）的縮寫。它的發展是萬維網協會（World

深入理解hostname

network 配置文件 release linux 知識點 當我覺得對Linux系統下修改hostname已經非常熟悉的時候，今天碰到了幾個個問題，這幾個問題給我好好上了一課，很多知識點，當你覺得你已經掌握的時候，其實你了解的還只是皮毛。技術活，切勿淺嘗則止！實驗環境：Red Hat E

C語言中switch...case語句中break的重要性

不能 實現 比例 重要性 case語句 毫無 ... 應該 switch 在C語言中switch...case語句是經常用到的，下面我介紹一下在使用該語句時候需要註意的一個細節問題。話不多說，直接舉例子： 例子1： switch(fruit) { case 1:printf

javascript深入理解js閉包

bag 思考 2個 表達式 proto window對象 來看 連接 第一次 閉包（closure）是Javascript語言的一個難點，也是它的特色，很多高級應用都要依靠閉包實現。 一、變量的作用域 要理解閉包，首先必須理解Javascript特殊的變量作用域。

JSON 的深入理解

jos 數據轉換 不同 宋體 ges 分隔 blog 結構 集合 JSON 知識 JSON(JavaScript Object Notataion)javascript的對象表示形式，但是目前已經發展為一種輕量級的數據交互格式。 特點：完全獨立於語言的文本格式，跨平臺，有結

深入理解 CSS3 彈性盒布局模型

分辨率 top 應用 時間 控制 用戶 lock fire 應用開發 彈性盒布局模型（Flexible Box Layout）是 CSS3 規範中提出的一種新的布局方式。該布局模型的目的是提供一種更加高效的方式來對容器中的條目進行布局、對齊和分配空間。這種布局

深入理解javascript之設計模式

rip 是我 解決問題 不想 接受 button move center 常識 設計模式 設計模式是命名、抽象和識別對可重用的面向對象設計實用的的通用設計結構。設計模式確定類和他們的實體、他們的角色和協作、還有他們的責任分配。 每個設計模式都聚焦於一個面向對象的設計難題

switch… case 語句的用法

[] other sta rgs bsp str 復制代碼 ring 表達 public class Test7 { public static void main(String[] args) { int i=5; switch

(轉)final關鍵字的深入理解

多線程 body error app nds ann this tar order 轉自http://www.importnew.com/7553.html Java中的final關鍵字非常重要，它可以應用於類、方法以及變量。這篇文章中我將帶你看看什麽是final關鍵字？將

深入理解計算機系統-作業2.10

oid 位置 pla borde 作業2 nbsp body 開始 width 1 void inplace_swap(int *x, int *y){ 2 *y = *x ^ *y;/*step1*/ 3 *x = *x ^ *y;/*step2*/ 4

深入理解Activity啟動流程(二)–Activity啟動相關類的類圖

b- ive ava ani affinity server 組織 詳細 pac 本文原創作者:Cloud Chou. 歡迎轉載，請註明出處和本文鏈接 本系列博客將詳細闡述Activity的啟動流程，這些博客基於Cm 10.1源碼研究。 在介紹Activity的詳細啟動流程

深入理解HTTP協議

不想 session 位與 裏的 ec2 只需要 空間 html文檔 動態 1. 基礎概念篇 1.1 介紹 HTTP是Hyper Text Transfer Protocol（超文本傳輸協議）的縮寫。它的發展是萬維網協會（World Wide Web Consortiu