要弄清楚 if/switch 的本质区别，以及优化方式

关注
发布于: 2020 年 05 月 21 日
先看看Sonar 的标准要求"switch" statements should have at least 3 "case" clauses
建议小于3个case的时候可以使用if代替，探索下为什么？
public class JmhRun {
    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                // 导入要测试的类
                .include(JudgeCompare_5.class.getSimpleName())
                // 预热5轮
                .warmupIterations(5)
                // 度量10轮
                .measurementIterations(10)
                .mode(Mode.Throughput)
                .forks(3)
                .build();
        new Runner(opt).run();
    }
}
﻿
public class JudgeCompare_5 {
    @Benchmark
    public void testIf_3() {
        int a = 3;
        if (a == 1) {
        }
        if (a == 2) {
        }
        if (a == 3) {
        }
    }
    @Benchmark
    public void testSwitch_3() {
        int a = 3;
        switch (a) {
            case 1:
                break;
            case 2:
                break;
            case 3:
                break;
            default:
        }
    }
    @Benchmark
    public void testIf_5() {
        int a = 3;
        if (a == 1) {
        }
        if (a == 2) {
        }
        if (a == 3) {
        }
        if (a == 4) {
        }
        if (a == 5) {
        }
    }
    @Benchmark
    public void testSwitch_5() {
        int a = 3;
        switch (a) {
            case 1:
                break;
            case 2:
                break;
            case 3:
                break;
            case 4:
                break;
            case 5:
                break;
            default:
        }
    }
    @Benchmark
    public void testIf_10() {
        int a = 3;
        if (a == 1) {
        }
        if (a == 2) {
        }
        if (a == 3) {
        }
        if (a == 4) {
        }
        if (a == 5) {
        }
        if (a == 6) {
        }
        if (a == 7) {
        }
        if (a == 8) {
        }
        if (a == 9) {
        }
        if (a == 10) {
        }
    }
    @Benchmark
    public void testSwitch_10() {
        int a = 3;
        switch (a) {
            case 1:
                break;
            case 2:
                break;
            case 3:
                break;
            case 4:
                break;
            case 5:
                break;
            case 6:
                break;
            case 7:
                break;
            case 8:
                break;
            case 9:
                break;
            case 10:
                break;
            default:
        }
    }
}
跑出来的性能结果如下：在本机mac上验证的结果与sonar的验证稍微有些出入，但是可以看出5个以上case还是能够证明switch性能要更优的。
写一个简短的例子，转成字节码后查看下具体的指令：javap -p -l -c JudgeCompare.class
public class JudgeCompare {
    private  void checkIfTime() {
        int cif = 1;
        if (cif < 0) {
            System.out.println("cif"+cif);
        }
        if (cif >= 1) {
            System.out.println("cif"+cif);
        }
    }
    private  void checkSwitchTime() {
        int cst = 2;
        switch (cst) {
            case 0:
                System.out.println("cst="+cst);
                break;
            case 1:
                System.out.println("cst="+cst);
                break;
            default:
                System.out.println("cst="+cst);
        }
    }
    public static void main(String[] args) {
        JudgeCompare jc = new JudgeCompare();
        jc.checkIfTime();
        jc.checkSwitchTime();
    }
}
private void checkIfTime();
    Code:
      0: iconst_1
      1: istore_1
      2: iload_1
      3: ifge          31                  //如果int比较为零成功，则分支. ifge succeeds if and only if value ≥ 0
      6: getstatic    #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      9: new          #3                  // class java/lang/StringBuilder
      12: dup
      13: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      16: ldc          #5                  // String cif
      18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: iload_1
      22: invokevirtual #7                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      25: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      28: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      31: iload_1
      32: iconst_1
      33: if_icmplt    61                  //当且仅当value1 <value2时，if_icmplt成功
      36: getstatic    #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      39: new          #3                  // class java/lang/StringBuilder
      42: dup
      43: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      46: ldc          #5                  // String cif
      48: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      51: iload_1
      52: invokevirtual #7                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      55: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      58: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      61: return
    LineNumberTable:
      line 5: 0
      line 6: 2
      line 7: 6
      line 9: 31
      line 10: 36
      line 12: 61
    LocalVariableTable:
      Start  Length  Slot  Name  Signature
          0      62    0  this  Lcom/zc/performance/JudgeCompare;
          2      60    1  cif  I
private void checkSwitchTime();
    Code:
      0: iconst_2  //将int常量cst=2压入操作数堆栈。
      1: istore_1  //将cst存储到局部变量
      2: iload_1    //从局部变量加载cst
      3: lookupswitch  { // 2    //通过键匹配和跳转访问跳转表
                    0: 28
                    1: 56
              default: 84
          }
      28: getstatic    #2                  // Field java/lang/System.out:Ljava/io/PrintStream; 从类中获取静态字段
      31: new          #3                  // class java/lang/StringBuilder  //准备pringln()的入参
      34: dup                              // 复制最高操作数堆栈值
      35: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V 调用实例方法；对超类，私有和实例初始化方法调用的特殊处理
      38: ldc          #10                // String cst=  从运行时常量池中推送项目
      40: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      43: iload_1
      44: invokevirtual #7                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      47: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      50: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      53: goto          109                // 进入指定操作码地址执行
      56: getstatic    #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      59: new          #3                  // class java/lang/StringBuilder
      62: dup
      63: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      66: ldc          #10                // String cst=
      68: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      71: iload_1
      72: invokevirtual #7                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      75: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      78: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      81: goto          109
      84: getstatic    #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
      87: new          #3                  // class java/lang/StringBuilder
      90: dup
      91: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      94: ldc          #10                // String cst=
      96: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      99: iload_1
    100: invokevirtual #7                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
    103: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
    106: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
    109: return
    LineNumberTable:
      line 15: 0
      line 16: 2
      line 18: 28
      line 19: 53
      line 21: 56
      line 22: 81
      line 24: 84
      line 26: 109
    LocalVariableTable:
      Start  Length  Slot  Name  Signature
          0    110    0  this  Lcom/zc/performance/JudgeCompare;
          2    108    1  cst  I
Compiled from "JudgeCompare.java"
public class com.zc.performance.JudgeCompare {
//默认的构造方法，在构造方法执行时主要完成一些初始化操作，包括一些成员变量的初始化赋值等操作
  public com.zc.performance.JudgeCompare();
    Code:
      0: aload_0      //从本地变量表中加载索引为0的变量的值，也即this的引用，压入栈
      1: invokespecial #1  //出栈，调用java/lang/Object."<init>":()V 初始化对象，就是this指定的对象的init()方法完成初始化
      4: return
    //指令与代码行数的偏移对应关系，每一行第一个数字对应代码行数，第二个数字对应前面code中指令前面的数字
    LineNumberTable:
      line 3: 0
    //局部变量表，start+length表示这个变量在字节码中的生命周期起始和结束的偏移位置（this生命周期从头0到结尾5），slot就是这个变量在局部变量表中的槽位（槽位可复用），name就是变量名称，Signatur局部变量类型描述
    LocalVariableTable:
      Start  Length  Slot  Name  Signature
          0      5    0  this  Lcom/zc/performance/JudgeCompare;
  public static void main(java.lang.String[]);
    Code:
    // new指令，创建一个class com/zc/performance/JudgeCompare对象，new指令并不能完全创建一个对象，对象只有在调用初始化方法完成后（也就是调用了invokespecial指令之后），对象才创建成功.
      0: new          #11                  //创建对象，并将对象引用压入栈
      3: dup                                //将操作数栈定的数据复制一份，并压入栈，此时栈中有两个引用值
      4: invokespecial #12                //pop出栈引用值,调用其构造函数，完成对象的初始化,这个时候才有真正的JudgeCompare对象
      7: astore_1                          //pop出栈引用值，将其（引用）赋值给局部变量表中的变量jc
      8: aload_1      //将jc的引用值压入栈，因为jc.checkIfTime();调用了jc，这里使用aload_1从局部变量表中获得对应的变量jc的值并压入操作数栈           
      9: invokespecial #13                // Method checkIfTime:()V 引用出栈，调用jc的checkIfTime()方法
      12: aload_1                          //将jc的引用值压入栈
      13: invokespecial #14                // Method checkSwitchTime:()V 引用出栈，调用jc的checkSwitchTime()方法
      16: return
    LineNumberTable:
      line 29: 0
      line 30: 8
      line 31: 12
      line 32: 16
    //局部变量表
    LocalVariableTable:
      Start  Length  Slot  Name  Signature
          0      17    0  args  [Ljava/lang/String;
          8      9    1    jc  Lcom/zc/performance/JudgeCompare;
}
过最终的操作指令可以对比出两种方式的区别，使用if的时候需要每次iload局部变量，从操作栈中为其赋值。而switch则是在寄存器中维护了一个跳转链表，根据匹配key值(只加载一次)，通过goto指令直接跳转到所要执行的偏移量地址处执行。匹配偏移量要比线性的按序搜索更快。
﻿
由于if是按顺序加载匹配，所以在使用if时尽量将匹配概率高的放到前面，并且建议在匹配后通过return快速返回，避免后面不匹配的条件被执行；由于switch优先匹配的是default，所以适用多数条件不匹配的场景。
优化if-else代码的八种方案﻿
代码中如果if-else比较多，阅读起来比较困难，维护起来也比较困难，很容易出bug，接下来，本文将介绍优化if-else代码的八种方案。转载至https://mp.weixin.qq.com/s/mi0KVS-jO0rk96g7wRdhFw
﻿
﻿
优化方案一：提前return，去除不必要的else如果if-else代码块包含return语句，可以考虑通过提前return，把多余else干掉，使代码更加优雅。
﻿
优化前：
if(condition){
    //doSomething   
}else{
    return;
}
﻿
优化后：
if(!condition){
    return;
}
//doSomething
优化方案二：使用条件三目运算符使用条件三目运算符可以简化某些if-else,使代码更加简洁，更具有可读性。
﻿
优化前：
int  price ;
if(condition){
   price =80;
}else{
   price =100;
}
﻿
优化后：
int price = condition?80:100;
﻿
优化方案三：使用枚举在某些时候，使用枚举也可以优化if-else逻辑分支，按个人理解，它也可以看作一种表驱动方法。
﻿
优化前：
String OrderStatusDes;
if (orderStatus == 0) {
    OrderStatusDes = "订单未支付";
}else if(OrderStatus == 1) {
    OrderStatusDes = "订单已支付";
}else if(OrderStatus == 2) {
    OrderStatusDes = "已发货";
}
﻿
优化后：
﻿
先定义一个枚举
public enum OrderStatusEnum {
    UN_PAID(0, "订单未支付"), PAIDED(1, "订单已支付"), SENDED(2, "已发货"),;
    private int index;
    private String desc;
    public int getIndex () {
        return index;
    }
    public String getDesc(){
        return desc;
    }
    OrderStatusEnum(int index,String desc){
        this.index = index;
        this.desc =desc;
    }
    OrderStatusEnum of(int orderStatus){
        for(OrderStatusEnum temp :OrderStatusEnum.values()){
            if(temp.getIndex()== orderStatus){
                return temp;
            }
        }
        return null;
    }
}
﻿
有了枚举之后，以上if-else逻辑分支，可以优化为一行代码
﻿
String OrderStatusDes = OrderStatusEnum.0f(orderStatus).getDesc();
﻿
优化方案四：合并条件表达式如果有一系列条件返回一样的结果，可以将它们合并为一个条件表达式，让逻辑更加清晰。
﻿
优化前
﻿
double getVipDiscount () {
    if (age < 18) {
        return 0.8;
    }
    if ("深圳".equals(city)) {
    		return 0.8;
    }
    if (isStudent) {
        return 0.8;
    }
    //do somethig
}
﻿
优化后
﻿
double getVipDiscount () {
    if (age < 18 || "深圳".equals(city) || isStudent) {
        return 0.8;
    }
    //doSomthing
}
﻿
优化方案五：使用 Optional有时候if-else比较多，是因为非空判断导致的，这时候你可以使用java8的Optional进行优化。
﻿
优化前：
String str = "jay@huaxiao";
if (str != null) {
    System.out.println(str);
} else {
    System.out.println("Null");
}
﻿
优化后：
﻿
Optional<String> strOptional = Optional.of("jay@huaxiao");
strOptional.ifPresentOrElse(System.out::println,()->System.out.println("Null"));
﻿
优化方案六：表驱动法表驱动法，表驱动方法是一种使你可以在表中查找信息，而不必用很多的逻辑语句（if或case）来把它们找出来的方法。以下的demo，把map抽象成表，在map中查找信息，而省去不必要的逻辑语句。
﻿
优化前：
if (param.equals(value1)) {
    doAction1(someParams);
}else if(param.equals(value2)) {
    doAction2(someParams);
}else if(param.equals(value3)) {
    doAction3(someParams);
}
﻿
优化后：
Map<?,Function<?> action> actionMappings =new HashMap<>();// 这里泛型 ? 是为方便演示，实际可替换为你需要的类型
// 初始化
actionMappings.put(value1,(someParams)->{ doAction1(someParams)});
actionMappings.put(value2,(someParams)->{ doAction2(someParams)});
actionMappings.put(value3,(someParams)->{ doAction3(someParams)});
// 省略多余逻辑语句
actionMappings.get(param).apply(someParams);
﻿
优化方案七：优化逻辑结构，让正常流程走主干优化前：
﻿
public double getAdjustedCapital () {
    if (_capital <= 0.0) {
        return 0.0;
    }
    if (_intRate > 0 && _duration > 0) {
        return (_income / _duration) * ADJ_FACTOR;
    }
    return 0.0;
}
﻿
优化后：
﻿
publicdouble getAdjustedCapital () {
    if (_capital <= 0.0) {
        return 0.0;
    }
    if (_intRate <= 0 || _duration <= 0) {
        return 0.0;
    }
    return (_income / _duration) * ADJ_FACTOR;
}
﻿
将条件反转使异常情况先退出，让正常流程维持在主干流程，可以让代码结构更加清晰。
优化方案八：策略模式+工厂方法消除if else假设需求为，根据不同勋章类型，处理相对应的勋章服务，优化前有以下代码：
String medalType = "guest";
if ("guest".equals(medalType)) {
    System.out.println("嘉宾勋章");
} else if("vip".equals(medalType)) {
    System.out.println("会员勋章");
} else if("guard".equals(medalType)) {
    System.out.println("展示守护勋章");
}
﻿
首先，我们把每个条件逻辑代码块，抽象成一个公共的接口，可以得到以下代码：
﻿
定义勋章接口
public interface IMedalService {
    void showMedal();
    String getMedalType();
}
﻿
我们根据每个逻辑条件，定义相对应的策略实现类，可得以下代码：
﻿
1、守护勋章策略实现类
public class GuardMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("展示守护勋章");
    }
    @Override
    public String getMedalType() {
        return "guard";
    }
}
﻿
2、嘉宾勋章策略实现类
public class GuestMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("嘉宾勋章");
    }
    @Override
    public String getMedalType() {
        return "guest";
    }
}
﻿
3、VIP勋章策略实现类
public class VipMedalServiceImpl implements IMedalService {
    @Override
    public void showMedal() {
        System.out.println("会员勋章");
    }
    @Override
    public String getMedalType() {
        return "vip";
    }
}
﻿
接下来，我们再定义策略工厂类，用来管理这些勋章实现策略类，如下：
﻿
勋章服务工产类
public class MedalServicesFactory {
    private static final Map<String, IMedalService> map = newHashMap <>();
    static {
        map.put("guard", newGuardMedalServiceImpl());
        map.put("vip", newVipMedalServiceImpl());
        map.put("guest", newGuestMedalServiceImpl());
    }
    public static IMedalService getMedalService(String medalType) {
        return map.get(medalType);
    }
}
﻿
使用了策略+工厂模式之后，代码变得简洁多了，如下：
public class Test {
    public static void main(String[] args) {
        String medalType = "guest";
        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);
        medalService.showMedal();
    }
}
通过设计模式消除分支判断在很多场景下效果不是立竿见影的，甚至有时会被质疑是否过度的抽象，但是这是一个持续迭代重构的必要过程，随着项目的不断迭代用好设计模式，后期的价值体现越明显。