面试题：switch语句能否作用在byte上,能否作用在long上,能否作用在String上？_swtich是否能作用在byte上,是否能作用在long上,是否能作用在string上-优快云博客

本文深入探讨 Java 中 switch 语句的使用方法及其内部实现原理，解释了 switch 如何处理不同类型，包括基本类型、包装类、枚举类型以及字符串。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
* 问题：switch语句能否作用在byte上,能否作用在long上,能否作用在String上
* 基本类型的包装类（如：Character、Byte、Short、Integer）
*
* switch可作用于char byte short int
* switch可作用于char byte short int对应的包装类
* switch不可作用于long double float boolean，包括他们的包装类
* switch中可以是字符串类型,String(jdk1.7之后才可以作用在string上)
* switch中可以是枚举类型

java基础(六) switch语句的深入解析

引言

switch 语句是非常的基础的知识，掌握起来也不难掌握，语法比较简单。但大部分人基本是知其然，不知其所以然。譬如早期JDK只允许switch的表达式的值 int及int类型以下的基本类型，后期的JDK却允许匹配比较字符串、枚举类型，这是怎么做到的呢？原理是什么？本文将深入去探索。

一、switch 介绍

switch 语法格式：

 switch (表达式) {
		case 常量表达式或枚举常量:
			语句;
			break;
		case 常量表达式或枚举常量:
			语句;
			break;
		......
		default: 语句;
			break;
	}

switch 匹配的表达式可以是：

byte、short、char、int类型及这4种类型的包装类型；
枚举类型；
String 类型；

case 匹配的表达式可以是：

常量表达式；
枚举常量；

注意一点： case提供了switch表达式的入口地址，一旦switch表达式与某个case分支匹配，则从该分支的语句开始执行，一直执行下去，即其后的所有case分支的语句也会被执行，直到遇到break语句。

看个例子体会一下：

public static void main(String[] args) {
		String  s = "a";
		
        switch (s) {
		case "a": //a分支
			 System.out.println("匹配成功1");
			    
		case "b": //b分支
		        System.out.println("匹配成功2");
		        
		case "c": //c分支
		         System.out.println("匹配成功3");
		         break;
		case "d": //d分支
		         System.out.println("匹配成功4");
		         break;
		default:
			break;
		}
	}

运行结果：

匹配成功1
匹配成功2
匹配成功3

switch成功匹配了a分支，但a、b分支都没有 break 语句，所以一直执行a分支后的所有语句，直到遇到c分支的break语句才终止。

二、编译器对 switch 表达式的各种类型的处理

尽管 switch 支持的类型扩充了几个，但其实在底层中，swtich 只能支持4种基本类型，其他几个类型是通过一些方式来间接处理的，下面便是讲解编译器对扩充类型的处理。

1、对包装类的处理

对包装类的处理是最简单的 —— 拆箱。看下面的例子，switch 比较的是包装类 Byte 。

		Byte b = 2;

		switch (b) {

		case 1:
			System.out.println("匹配成功");
			break;
		case 2:
			System.out.println("匹配成功");
			break;
		}

用jad反编译一下这段代码，得到的代码如下：

        Byte b = Byte.valueOf((byte)2);

        switch(b.byteValue())
        {
        case 1: // '\001'
            System.out.println("\u5339\u914D\u6210\u529F");
            break;

        case 2: // '\002'
            System.out.println("\u5339\u914D\u6210\u529F");
            break;
        }

反编译的代码很简单，底层的switch比较的是Byte通过（拆箱）方法byteValue()得到的byte值。顺便说一下，这段反编译代码不仅揭开了拆箱的解析原理，也展示了装箱的解析原理（第一句代码）；

2. 枚举类型

为了简单起见，直接采用JDK提供的枚举类型的线程状态类 Thread.state 类。

	Thread.State state = Thread.State.RUNNABLE;
		
	switch (state) {
	case NEW:
		System.out.println("线程处于创建状态");
		break;
	case RUNNABLE:
		System.out.println("线程处于可运行状态");
		break;
	case TERMINATED:
		System.out.println("线程结束");
		break;

	default:
		break;
}

反编译代码：

Sex sex = Sex.MALE;
        switch($SWITCH_TABLE$Test_2018_1_14$Sex()[sex.ordinal()])
        {
        case 1: // '\001'
            System.out.println("sex:male");
            break;

        case 2: // '\002'
            System.out.println("sex:female");
            break;
        }

从编译代码中发现，编译器对于枚举类型的处理，是通过创建一个辅助数组来处理，这个数组是通过一个$SWITCH_TABLE$java$lang$Thread$State() 方法创建的，数组是一个int[]类型数组，数组很简单，在每个枚举常量的序号所对应的数组下标位置的赋一个值，按序号大小赋值，从1开始递增。其代码如下：

//int 数组
private static int $SWITCH_TABLE$java$lang$Thread$State[];

//创建数组的方法
static int[] $SWITCH_TABLE$java$lang$Thread$State()
    {
        $SWITCH_TABLE$java$lang$Thread$State;
        if($SWITCH_TABLE$java$lang$Thread$State == null) goto _L2; else goto _L1
_L1:
        return;
_L2:
        JVM INSTR pop ;
        int ai[] = new int[Thread.State.values().length];
        try
        {
            ai[Thread.State.BLOCKED.ordinal()] = 3;
        }
        catch(NoSuchFieldError _ex) { }
        try
        {
            ai[Thread.State.NEW.ordinal()] = 1;
        }
        catch(NoSuchFieldError _ex) { }
        try
        {
            ai[Thread.State.RUNNABLE.ordinal()] = 2;
        }
        catch(NoSuchFieldError _ex) { }
        try
        {
            ai[Thread.State.TERMINATED.ordinal()] = 6;
        }
        catch(NoSuchFieldError _ex) { }
        try
        {
            ai[Thread.State.TIMED_WAITING.ordinal()] = 5;
        }
        catch(NoSuchFieldError _ex) { }
        try
        {
            ai[Thread.State.WAITING.ordinal()] = 4;
        }
        catch(NoSuchFieldError _ex) { }
        return $SWITCH_TABLE$java$lang$Thread$State = ai;
    }
}

3、对String类型的处理

依旧是先看个例子，再查看这个例子反编译代码，了解编译器的是如何解析的。

public static void main(String[] args) {
		String  s = "China";
		
        switch (s) {
		case "America": 
			     System.out.println("匹配到美国");
			     break;
		case "China": 
		        System.out.println("匹配到中国");
		        break;
		case "Japan": 
		         System.out.println("匹配到日本");
		default:
			break;
		}
	}

反编译得到的代码：

  public static void main(String args[])
    {
        String s = "China";
        String s1;
        switch((s1 = s).hashCode())
        {
        default:
            break;

        case 65078583: 
            if(s1.equals("China"))
                System.out.println("\u5339\u914D\u5230\u4E2D\u56FD");
            break;

        case 71341030: 
            if(s1.equals("Japan"))
                System.out.println("\u5339\u914D\u5230\u65E5\u672C");
            break;

        case 775550446: 
            if(s1.equals("America"))
                System.out.println("\u5339\u914D\u5230\u7F8E\u56FD");
            break;
        }
    }

从反编译的代码可以看出，switch 的String变量、case 的String常量都变成对应的字符串的 hash 值。也就是说，switch仍然没有超出它的限制，只是通过使用 String对象的hash值来进行匹配比较，从而支持 String 类型。

总结：

底层的switc只能处理4个基本类型的值。其他三种类型需要通过其他方式间接处理，即转成基本类型来处理。
编译器对包装类的处理是通过拆箱。
对枚举类型的处理，是通过枚举常量的序号及一个数组。
对字符串String的处理，是通过 String 的hash值。

switch的转换和具体系统实现有关，如果分支比较少，可能会转换为跳转指令（条件跳转指令和无条件跳转指令）。但如果分支比较多，使用条件跳转会进行很多次的比较运算，效率比较低，可能会使用一种更为高效的方式，叫跳转表。跳转表是一个映射表，存储了可能的值以及要跳转到的地址，形如：

值1	代码块1的地址
值2	代码块2的地址
...
值n	代码块n的地址

跳转表为什么会更为高效呢？因为，其中的值必须为整数，且按大小顺序排序。按大小排序的整数可以使用高效的二分查找，即先与中间的值比，如果小于中间的值则在开始和中间值之前找，否则在中间值和末尾值之间找，每找一次缩小一倍查找范围，其算法复杂度为O(log2n)。

如果值是连续的，则跳转表还会进行特殊优化，优化为一个数组，连找都不用找了，值就是数组的下标索引，直接根据数组下标索引就可以找到跳转的地址。

即使值不是连续的，但数字比较密集，差的不多，编译器也可能会优化为一个数组型的跳转表，没有的值指向default分支。

程序源代码中的case值排列不要求是排序的，编译器会自动排序。switch判断的类型可以是byte, short, int, char, 枚举和String（java7及之后支持）。其中byte/short/int/char本来就是整数，而枚举类型也有对应的整数序号ordinal，String用于switch时也会通过hashCode方法转换为整数，为什么不可以使用long呢？因为跳转表值的存储空间一般为32位，容纳不下long。

需要说明下String的hashCode值可能冲突，而解决冲突的方式就是跳转之后再通过equals方法判定字符串内容是否相等。

例如下面代码：

    String s = "123456";
    switch (s) {
    case "123": {
      System.out.println("s值为123");
    }
    }

编译后代码大概为：

    String s = "123456";
    String str1;
    switch ((str1 = s).hashCode())
    {
    case 48690: //48690是"123"的hashcode
      if (str1.equals("123")) {
        System.out.println("s值为123");
      }
    }

本文参考书籍《Java编程的逻辑》

转载于:https://www.cnblogs.com/JackPn/p/9382869.html

原文地址: https://www.cnblogs.com/jinggod/p/8425260.html