java:集合的自定义多重排序

问题：

有一个乱序的对象集合，要求先按对象的属性A排序（排序规则由业务确定，非A-Z或0-9的常规顺序），相同A属性的记录，按根据属性B排序（排序规则，同样由业务确定，非常规顺序） -前提：业务规则是明确的

示例：

FSUData对象定义

 package acc.test;

 public class FSUData {

     public FSUData(String airport, String fsuCode) {
         this.airport = airport;
         this.fsuCode = fsuCode;
     }

     /**
      * 航站
      */
     private String airport;

     /**
      * FSU状态节点
      */
     private String fsuCode;

     public String getAirport() {
         return airport;
     }

     public void setAirport(String airport) {
         this.airport = airport;
     }

     public String getFsuCode() {
         return fsuCode;
     }

     public void setFsuCode(String fsuCode) {
         this.fsuCode = fsuCode;
     }

     public String toString() {
         return airport + "/" + fsuCode;
     }

 }

原始数据：

[法兰克福/RCF, 法兰克福/DLV, 成都/DEP, 成都/RCS, 上海/DEP, 上海/RCF]

业务规则：

航站排序规则：成都 -> 上海 -> 法兰克福

FSU排序规则：RCS -> RCF -> TFD -> DEP -> DLV

要求排序后变成下面这样：

[成都/RCS, 成都/DEP, 上海/RCF, 上海/DEP, 法兰克福/RCF, 法兰克福/DLV]

java代码：

 package acc.test;

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

 import org.junit.Test;

 public class FSUSortTest {

     Map<String, Integer> airportDic = new HashMap<String, Integer>();
     Map<String, Integer> fsuDic = new HashMap<String, Integer>();

     @Test
     public void test() {

         // 先定义顺序规则
         airportDic.put("成都", 1);
         airportDic.put("上海", 2);
         airportDic.put("法兰克福", 3);

         fsuDic.put("RCS", 1);
         fsuDic.put("RCF", 2);
         fsuDic.put("TFD", 3);
         fsuDic.put("DEP", 4);
         fsuDic.put("DLV", 5);

         // 建一个待排序的目标"数组"
         List<FSUData> target = new ArrayList<FSUData>();

         target.add(new FSUData("法兰克福", "RCF"));
         target.add(new FSUData("法兰克福", "DLV"));

         target.add(new FSUData("成都", "DEP"));
         target.add(new FSUData("成都", "RCS"));

         target.add(new FSUData("上海", "DEP"));
         target.add(new FSUData("上海", "RCF"));

         System.out.println("排序前：" + target);

         // 排序
         FsuComparator fsuComparator = new FsuComparator(airportDic, fsuDic);
         Collections.sort(target, fsuComparator);

         System.out.println("排序后：" + target);
     }

     private class FsuComparator implements Comparator<FSUData> {

         Map<String, Integer> airportMap;
         Map<String, Integer> fsuMap;

         public FsuComparator(Map<String, Integer> airportMap,
                 Map<String, Integer> fsuMap) {
             this.airportMap = airportMap;
             this.fsuMap = fsuMap;
         }

         public int compare(FSUData s1, FSUData s2) {

             // 从顺序规则Map里，取出"排序值"
             Integer airportOrder1 = airportMap.get(s1.getAirport());
             Integer airportOrder2 = airportMap.get(s2.getAirport());

             // 如果Airport相同，则比较FSUCode
             if (airportOrder1 == airportOrder2) {
                 Integer fsuOrder1 = fsuMap.get(s1.getFsuCode());
                 Integer fsuOrder2 = fsuMap.get(s2.getFsuCode());
                 return fsuOrder1.compareTo(fsuOrder2);
             }

             return airportOrder1.compareTo(airportOrder2);
         }
     }

 }

思路：先将"业务排序规则" 转换成 "常规有序规则"，然后再利用Comparator接口实现比较