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

用户头像
张驰
关注
发布于: 2020 年 05 月 21 日
要弄清楚if/switch的本质区别,以及优化方式

先看看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();
    }
}

通过设计模式消除分支判断在很多场景下效果不是立竿见影的,甚至有时会被质疑是否过度的抽象,但是这是一个持续迭代重构的必要过程,随着项目的不断迭代用好设计模式,后期的价值体现越明显。

用户头像

张驰

关注

还未添加个人签名 2018.03.29 加入

还未添加个人简介

评论

发布
暂无评论
要弄清楚if/switch的本质区别,以及优化方式