巧妙利用JDK1.8新特性解决多if判断及其性能测试

        先说说场景，最近接第三方的足球走地数据，需要将这些数据入库，设计到一个足球的eventType的整理，我们自己的库中有一套我们自己的eventType，这些eventType包括进球，红黄牌等事件。第三方数据可能将两个队的进球事件分开成HomeGoal和AwayGoal事件，而在我们的库中将这两个事件合并成一个事件Goal。

       将第三方的事件对应到我们自己库中的事件，在解决方式上你可能想到的第一个方法是使用if或者switch case，或者某种设计模式。我想说这些方式都不可取，先说if和switch case，eventType种类太多，当前有20多种，还不能保证以后只减不增，用if或者switch case，你确定你要写20++种if或case判断吗？再说使用设计模式，使用策略模式？不管使用何种设计模式，面对20++种eventType，需要20++个类，还要随着以后eventType的动态增加来随时增加类，随时维护代码。违背原则。

        那是不是就要问了，那有什么好的解决方案呢？我建议的解决方案是使用enum+jdk1.8新特性。前提是你的项目使用了jdk1.8哦。

        enum类可以这样定义：

<span style="font-size:18px;">import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.zhangyu.databus.core.enums.MatchEventType;
import com.zhangyu.databus.fetch.enums.BetgeniusSports;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* Created by zhudan on 2016/7/26.
*/
public enum BetgeniusEventType {
ALL(-1, "全部",MatchEventType.ALL),
AWAY_GOAL(0, "AwayGoal",MatchEventType.SCORE),
AWAY_PENALTY(1, "AwayPenalty",MatchEventType.PENALTY),
AWAY_DANGEROUS_FREEKICK(2, "AwayDangerousFreeKick",MatchEventType.DANGEROUS_FREE_KICK),
AWAY_CORNER(3, "AwayCorner",MatchEventType.CORNER),
AWAY_ATTACKING_FREEKICK(4, "AwayAttackingFreeKick",MatchEventType.DANGEROUS_FREE_KICK),
AWAY_DANGEROUS_ATTACK(5, "AwayDangerousAttack",MatchEventType.DANGEROUS_ATTACK),
AWAY_CORNER_DANGER(6, "AwayCornerDanger",MatchEventType.DANGEROUS_CORNER),
AWAY_ATTACK(7, "AwayAttack",MatchEventType.ATTACK),
AWAY_FREEKICK(8, "AwayFreeKick",MatchEventType.FREE_KICK),
AWAY_SAFE(9, "AwaySafe",MatchEventType.BALL_SAFE),
SAFE(10, "Safe",MatchEventType.BALL_SAFE),
HOME_SAFE(11, "HomeSafe",MatchEventType.BALL_SAFE),
HOME_FREEKICK(12, "HomeFreeKick",MatchEventType.FREE_KICK),
HOME_ATTACK(13, "HomeAttack",MatchEventType.ATTACK),
HOME_CORNER_DANGER(14, "HomeCornerDanger",MatchEventType.DANGEROUS_CORNER),
HOME_DANGEROUS_ATTACK(15, "HomeDangerousAttack",MatchEventType.DANGEROUS_ATTACK),
HOME_ATTACKING_FREEKICK(16, "HomeAttackingFreeKick",MatchEventType.DANGEROUS_FREE_KICK),
HOME_CORNER(17, "HomeCorner",MatchEventType.CORNER),
HOME_DANGEROUS_FREEKICK(18, "HomeDangerousFreeKick",MatchEventType.DANGEROUS_FREE_KICK),
HOME_PENALTY(19, "HomePenalty",MatchEventType.PENALTY),
HOME_GOAL(20, "HomeGoal",MatchEventType.SCORE),
YELLOWCARDDANGER(21, "YellowCardDanger",MatchEventType.POSSIBLE_YELLOW_CARD),
//TODO
AWAY_SAFE_FREEKICK(22, "AwaySafeFreeKick",MatchEventType.FREE_KICK),
HOME_SAFE_FREEKICK(23, "HomeSafeFreeKick",MatchEventType.FREE_KICK);

private static Logger logger = LoggerFactory.getLogger(BetgeniusSports.class);

private static final Object _LOCK = new Object();

private static Map<Integer, BetgeniusEventType> _MAP;
private static Map<String, BetgeniusEventType> _NAME_MAP;
private static Map<String, BetgeniusEventType> _STATE_MAP;
private static List<BetgeniusEventType> _LIST;
private static List<BetgeniusEventType> _ALL_LIST;

static {
synchronized (_LOCK) {
Map<Integer, BetgeniusEventType> map = new HashMap<>();
Map<String, BetgeniusEventType> nameMap = new HashMap<>();
Map<String,BetgeniusEventType> stateMap=new HashMap<>();
List<BetgeniusEventType> list = new ArrayList<>();
List<BetgeniusEventType> listAll = new ArrayList<>();
for (BetgeniusEventType item : BetgeniusEventType.values()) {
map.put(item.getValue(), item);
nameMap.put(item.getName(), item);
listAll.add(item);
if (!item.equals(ALL)) {
list.add(item);
}
}

_MAP = ImmutableMap.copyOf(map);
_NAME_MAP = ImmutableMap.copyOf(nameMap);
_STATE_MAP=ImmutableMap.copyOf(stateMap);
_LIST = ImmutableList.copyOf(list);
_ALL_LIST = ImmutableList.copyOf(listAll);
}
}

private int value;
private String name;
private MatchEventType matchEventType;

BetgeniusEventType(int value, String name, MatchEventType matchEventType) {
this.value = value;
this.name = name;
this.matchEventType=matchEventType;
}

public String getName() {
return name;
}

public int getValue() {
return value;
}

public MatchEventType getMatchEventType(){
return matchEventType;
}

public static BetgeniusEventType get(int value) {
try {
return _MAP.get(value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
return null;
}
}

public static BetgeniusEventType getByName(String name) {
try {
return _NAME_MAP.get(name);
} catch (Exception e) {
logger.error(e.getMessage(), e);
return null;
}
}

public static List<BetgeniusEventType> list() {
return _LIST;
}

public static List<BetgeniusEventType> listAll() {
return _ALL_LIST;
}

public static Map<String, BetgeniusEventType> getBetgeniusStateMap(){
return _STATE_MAP;
}
}</span>

        拿AWAY_GOAL(0,"AwayGoal",MatchEventType.SCORE)进行说明，0不用说，仅仅是个序号，"AwayGoal"是第三方数据的eventType，MatchEventType.SCORE是我们自己的一套eventType，enum类中的listAll和list方法，分别返回不同结构的list，其中我使用到了listAll方法，接着往下看。

    使用jdk1.8新特性中的stream().filter()结合lamda表达式，可以这样处理。直接返回MatchEventType中的name属性，即返回我们自己的这一套eventType。

<span style="font-size:18px;">BetgeniusEventType.listAll().stream().
filter((s) -> s.getName().equals("AwayGoal")).
findFirst().get().getMatchEventType().getName()</span>

   那这同普通的在for循环下取值然后进行if判断有什么优势呢？

   我做了一个简单的性能测试：

<span style="font-size:18px;">public static void main(String[] args) {
long foreachstart = System.currentTimeMillis();
for (BetgeniusEventType type:BetgeniusEventType.listAll()
) {
if(type.getName().equals("AwaySafe")){
System.out.println(type.getName());
}
}
long foreachend = System.currentTimeMillis();
System.out.println(foreachstart-foreachend);

long filterstart=System.currentTimeMillis();
System.out.println(BetgeniusEventType.listAll().stream().
filter((s) -> s.getName().equals("AwaySafe")).
findFirst().get().getName());
long filterend=System.currentTimeMillis();
System.out.println(filterstart-filterend);
}</span>

测试结果如下：

    


    咱既然选择了使用jdk1.8，那么也要明白jdk1.8相对于其他的版本来说有什么新的特性功能，试着去使用它们，给自己带来方便，会有意想不到的效果。