Java (optimization 28) optimizing if else writing

Optimization scheme 1: return in advance to remove unnecessary else

If the if-else code block contains a return statement, you can consider eliminating the redundant else by return in advance to make the code more elegant.

Before optimization:

if(condition){
     //doSomething 
}else{     
    return ; 
} 

After optimization:

if(!condition){    
     return ; 
} 
//doSomething 

Optimization scheme 2: use conditional binomial operator

Some if else operators can be simplified by using conditional binomial operators, which makes the code more concise and readable.

Before optimization:

int  price ; 
if(condition){    
     price = 80; 
}else{     
     price = 100; 
}

After optimization:

int price = condition?80:100;

Optimization scheme 3: use enumeration

In some cases, enumeration can also be used to optimize if else logical branches, which can also be seen as a table driven method according to personal understanding.

Before optimization:

String OrderStatusDes; 
if(orderStatus==0){     
    OrderStatusDes ="Order not paid"; 
}else if(OrderStatus==1){     
    OrderStatusDes ="Order paid"; 
}else if(OrderStatus==2){    
    OrderStatusDes ="Shipped"; 
} ...

After optimization:

public enum OrderStatusEnum {     
    UN_PAID(0,"Order not paid"),

    PAIDED(1,"Order paid"),

    SENDED(2,"Shipped"),; 
     
    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;     
    } 
} 

With enumeration, the above if else logic branch can be optimized to one line of code:

String OrderStatusDes = OrderStatusEnum.0f(orderStatus).getDesc();

Optimization scheme 4: merge condition expression

If a series of conditions return the same result, you can combine them into a conditional expression to make the logic clearer.

Before optimization:

double getVipDiscount() {         
    if(age<18){             
        return 0.8;         
    }  
       
    if("Shenzhen".equals(city)){             
        return 0.8;         
    }         

    if(isStudent){             
        return 0.8;         
     }         

     //do somethig     
}

After optimization:

double getVipDiscount(){         
    if(age<18|| "Shenzhen".equals(city)||isStudent){             
        return 0.8;         
     }         
     //doSomthing     
}

Optimization scheme 5: using Optional

Sometimes there are many if else, which is caused by non empty judgment. At this time, you can use java8's Optional to optimize.

Before optimization:

String str = "jay@huaxiao"; 
if (str != null) {    
     System.out.println(str); 
} else {     
     System.out.println("Null"); 
} 

After optimization:

Optional<String> strOptional = Optional.of("jay@huaxiao");
strOptional.ifPresentOrElse(System.out::println, () -> System.out.println("Null"));

Optimization scheme 6: table driven method

Table driven method, also known as table driven, table driven method. Table driven method is a method that enables you to find information in a table without using many logical statements (if or case).
The following demo abstracts the map into a table to find information in the map without unnecessary logical statements.

Before optimization:

if (param.equals(value1)) {     
    doAction1(someParams); 
} else if (param.equals(value2)) {     
    doAction2(someParams); 
} else if (param.equals(value3)) {     
    doAction3(someParams); 
} // ... 

After optimization:

Map<?, Function<?> action> actionMappings = new HashMap<>(); // Generics here? For demonstration purposes, they can be replaced with the types you need  
// Initialization 
actionMappings.put(value1, (someParams) -> { doAction1(someParams)}); 
actionMappings.put(value2, (someParams) -> { doAction2(someParams)});
actionMappings.put(value3, (someParams) -> { doAction3(someParams)});  
// Omit redundant logical statements 
actionMappings.get(param).apply(someParams); 

Optimization scheme 7: optimize the logical structure and let the normal process take the trunk

Before optimization:

public double getAdjustedCapital(){     
    if(_capital <= 0.0 ){         
        return 0.0;     
    } 
    
    if(_intRate > 0 && _duration >0){         
        return (_income / _duration) *ADJ_FACTOR;     
    } 
     return 0.0; 
} 

After optimization:

public double getAdjustedCapital(){     
    if(_capital <= 0.0 ){         
        return 0.0;     
    }     
    
    if(_intRate <= 0 || _duration <= 0){         
        return 0.0;     
    }      
    return (_income / _duration) *ADJ_FACTOR; 
} 

By reversing the conditions, the exception exits first, and the normal process is maintained in the main process, which can make the code structure clearer.

Optimization scheme 8: strategy mode + factory method to eliminate if else

Suppose that the requirement is to process the corresponding medal service according to different medal types. Before optimization, there is the following code:

String medalType = "guest"; 
if ("guest".equals(medalType)) {     
    System.out.println("Distinguished guests Medal");  
} else if ("vip".equals(medalType)) {     
    System.out.println("Medal of membership"); 
} else if ("guard".equals(medalType)) {    
    System.out.println("Display the guardian Medal"); 
} ...

First of all, we abstract each conditional logic code block into a common interface and get the following code:

//Medal interface 
public interface IMedalService {     
    void showMedal(); 
}

According to each logical condition, we define the corresponding policy implementation class and get the following code:

//Guard Medal strategy implementation class 
public class GuardMedalServiceImpl implements IMedalService {     
    @Override     
    public void showMedal() {         
        System.out.println("Display the guardian Medal");     
     } 
 } 

 //Guests medal strategy implementation class 
 public class GuestMedalServiceImpl implements IMedalService {     
        @Override     
        public void showMedal() {         
            System.out.println("Distinguished guests Medal");     
    } 
 } 

 //VIP medal strategy implementation class 
 public class VipMedalServiceImpl implements IMedalService {     
    @Override     
    public void showMedal() {         
        System.out.println("Medal of membership");     
    } 
 }

Next, we define the policy factory class to manage these medal implementation policy classes, as follows:

//Medal service industry 
public class MedalServicesFactory {      
    private static final Map<String, IMedalService> map = new HashMap<>();     
    static {         
        map.put("guard", new GuardMedalServiceImpl());         
        map.put("vip", new VipMedalServiceImpl());         
        map.put("guest", new GuestMedalServiceImpl());     
    }     

    public static IMedalService getMedalService(String medalType) {         
        return map.get(medalType);     
    } 
} 

After using the strategy + factory mode, the code becomes much more concise, as follows:

public class Test {     
    public static void main(String[] args) {         
        String medalType = "guest";         
        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);                 
        medalService.showMedal();     
    } 
} 

 

171 original articles published, 101 praised, 1.26 million visitors+
His message board follow

Posted on Wed, 11 Mar 2020 07:26:50 -0400 by AIS4U