乐趣区

关于java:Java中的-Switch-是如何支持-String-的为什么不支持-long

jiezi

咱们晓得 Java Switch 反对 byte、short、int 类型，在 JDK 1.5 时，反对了枚举类型，在 JDK 1.7 时，又反对了 String 类型。那么它为什么就不能反对 long 类型呢，明明它跟 byte、short、int 一样都是数值型，它又是咋反对 String 类型的呢？

一、论断

不卖关子，先说论断：

switch 底层是应用 int 型 来进行判断的，即便是枚举、String 类型，最终也是转变成 int 型。因为 long 型示意范畴大于 int 型，因而不反对 long 类型。

上面具体介绍下各个类型是如何被转变成 int 类型的，应用的编译命令为 javac，反编译网站为：http://javare.cn

二、枚举类型是咋变成 int 类型的？

在没有试验之前，我想当然的认为它是不是依据枚举的 int 型字段来计算的（因为个别枚举都是一个 int 型，一个 string 型），然而转念一想，万一枚举没有 int 型字段呢，万一有多个 int 型字段呢，所以必定不是这样的，上面看试验吧。

定义两个枚举类，一个枚举类有一个 int 型属性，一个 string 型属性，另外一个枚举类只有一个 string 属性：

public enum SexEnum {MALE(1, "男"),  
    FEMALE(0, "女");  
  
    private int type;  
  
    private String name;  
  
    SexEnum(int type, String name) {  
        this.type = type;  
        this.name = name;  
    }  
} 
public enum Sex1Enum {MALE("男"),  
    FEMALE("女");  
    private String name;  
  
    Sex1Enum(String name) {this.name = name;}  
}

而后编写一个测试类，并且让两个枚举 switch 的 FEMALE 和 MALE 对应的返回值不同：

public class SwitchTest {public int enumSwitch(SexEnum sex) {switch (sex) {  
            case MALE:  
                return 1;  
            case FEMALE:  
                return 2;  
            default:  
                return 3;  
        }  
    }  
  
    public int enum1Switch(Sex1Enum sex) {switch (sex) {  
            case FEMALE:  
                return 1;  
            case MALE:  
                return 2;  
            default:  
                return 3;  
        }  
    }  
}

将这几个类反编译下：

// SexEnum.class  
public enum SexEnum {MALE(1, "鐢�"),  
   FEMALE(0, "濂�");  
   private int type;  
   private String name;  
   // $FF: synthetic field  
   private static final SexEnum[] $VALUES = new SexEnum[]{MALE, FEMALE};  
  
  
   private SexEnum(int var3, String var4) {  
      this.type = var3;  
      this.name = var4;  
   }  
  
}  
  
// Sex1Enum.class  
public enum Sex1Enum {MALE("鐢�"),  
   FEMALE("濂�");  
   private String name;  
   // $FF: synthetic field  
   private static final Sex1Enum[] $VALUES = new Sex1Enum[]{MALE, FEMALE};  
  
  
   private Sex1Enum(String var3) {this.name = var3;}  
  
}

反编译这两个枚举类，发现其中多了一个 $VALUES 数组，外部蕴含了所有的枚举值。持续反编译测试类：

// SwitchTest$1.class  
import com.example.express.test.Sex1Enum;  
import com.example.express.test.SexEnum;  
  
// $FF: synthetic class  
class SwitchTest$1 {  
  
   // $FF: synthetic field  
   static final int[] $SwitchMap$com$example$express$test$SexEnum;  
   // $FF: synthetic field  
   static final int[] $SwitchMap$com$example$express$test$Sex1Enum = new int[Sex1Enum.values().length];  
  
  
   static {  
      try {$SwitchMap$com$example$express$test$Sex1Enum[Sex1Enum.FEMALE.ordinal()] = 1;  
      } catch (NoSuchFieldError var4) {;}  
  
      try {$SwitchMap$com$example$express$test$Sex1Enum[Sex1Enum.MALE.ordinal()] = 2;  
      } catch (NoSuchFieldError var3) {;}  
  
      $SwitchMap$com$example$express$test$SexEnum = new int[SexEnum.values().length];  
  
      try {$SwitchMap$com$example$express$test$SexEnum[SexEnum.MALE.ordinal()] = 1;  
      } catch (NoSuchFieldError var2) {;}  
  
      try {$SwitchMap$com$example$express$test$SexEnum[SexEnum.FEMALE.ordinal()] = 2;  
      } catch (NoSuchFieldError var1) {;}  
  
   }  
}

首先生成了一个名为 SwitchTest$1.java 的链接类，外面定义了两个枚举数组，这两个数组元素增加的程序齐全和测试类中 switch 类调用的程序统一。

枚举元素在数组中的下标由 ordinal() 函数决定，该办法就是返回枚举元素在枚举类中的序号。

这里咱们其实就曾经晓得了，在 switch 语句中，是依据枚举元素在枚举中的序号来转变成 int 型的。最初再看下测试类的反编译后果验证下：

// SwitchTest.class  
import com.example.express.test.Sex1Enum;  
import com.example.express.test.SexEnum;  
import com.example.express.test.SwitchTest.1;  
  
public class SwitchTest {public int enumSwitch(SexEnum var1) {switch(1.$SwitchMap$com$example$express$test$SexEnum[var1.ordinal()]) {  
      case 1:  
         return 1;  
      case 2:  
         return 2;  
      default:  
         return 3;  
      }  
   }  
  
   public int enum1Switch(Sex1Enum var1) {switch(1.$SwitchMap$com$example$express$test$Sex1Enum[var1.ordinal()]) {  
      case 1:  
         return 1;  
      case 2:  
         return 2;  
      default:  
         return 3;  
      }  
   }  
}

三、String 类型是咋变成 int 类型的？

首先咱们先晓得 char 类型是如何变成 int 类型的，很简略，是 ASCII 码，例如存在 switch 语句：

public int charSwitch(char c) {switch (c) {  
        case 'a':  
            return 1;  
        case 'b':  
            return 2;  
        default:  
            return Integer.MAX_VALUE;  
    }  
}

反编译后果：

public int charSwitch(char var1) {switch(var1) {  
        case 97:  
            return 1;  
        case 98:  
            return 2;  
        default:  
            return Integer.MAX_VALUE;  
    }  
}

那么对于 String 来说，利用的就是 hashCode() 函数了，然而 两个不同的字符串 hashCode() 是有可能相等的，这时候就得靠 equals() 函数了，例如存在 switch 语句：

public int stringSwitch(String ss) {switch (ss) {  
        case "ABCDEa123abc":  
            return 1;  
        case "ABCDFB123abc":  
            return 2;  
        case "helloWorld":  
            return 3;  
        default:  
            return Integer.MAX_VALUE;  
    }  
}

其中字符串 ABCDEa123abc 和 ABCDFB123abc 的 hashCode 是相等的，反编译后果为：

public int stringSwitch(String var1) {  
   byte var3 = -1;  
   switch(var1.hashCode()) {  
       case -1554135584:  
          if(var1.equals("helloWorld")) {var3 = 2;}  
          break;  
       case 165374702:  
          if(var1.equals("ABCDFB123abc")) {var3 = 1;} else if(var1.equals("ABCDEa123abc")) {var3 = 0;}  
   }  
  
   switch(var3) {  
       case 0:  
          return 1;  
       case 1:  
          return 2;  
       case 2:  
          return 3;  
       default:  
          return Integer.MAX_VALUE;  
   }  
}

能够看到它引入了局部变量 var3，对于 hashCode 相等状况通过 equals() 办法判断，最初再判断 var3 的值。

四、它们的包装类型反对吗？

这里以 Integer 类型为例，Character 和 Byte 同理，例如存在 switch 语句：

public int integerSwitch(Integer c) {switch (c) {  
        case 1:  
            return 1;  
        case 2:  
            return 2;  
    }  
    return -1;  
}

反编译后果为：

public int integerSwitch(Integer var1) {switch(var1.intValue()) {  
        case 1:  
            return 1;  
        case 2:  
            return 2;  
        default:  
            return -1;  
    }  
}

能够看到，是反对包装类型的，通过主动拆箱解决。

那万一包装类型是 NULL 咋办，首先咱们晓得 swtich 的 case 是不给加 null 的，编译都通不过，那如果传 null 呢？

答案是 NPE，毕竟理论还是包装类型的拆箱，天然就报空指针了。

作者：jitwxs
起源：https://jitwxs.cn/6f3eddff.html

欢送关注我的微信公众号「码农解围」，分享 Python、Java、大数据、机器学习、人工智能等技术，关注码农技术晋升•职场解围•思维跃迁，20 万 + 码农成长充电第一站，陪有幻想的你一起成长

退出移动版