ComparatorChain +Collections.sort

使用案例1：

  private List<Inventory> sortByRule(List<InventoryWrap> inventoryWraps
				,String turnOverMode) {
        //收集排序规则
        List<SortRule> sortRules = new ArrayList<SortRule>();
        //先按照库存周转排序
        if(turnOverMode != null){
        	if (TurnOverMode.FIFO_STORAGEDATE.equals(turnOverMode)) {
        		sortRules.add(new SortRule(2, "batch", "ASC"));//expireDate
        	} else if (TurnOverMode.LIFO_STORAGEDATE.equals(turnOverMode)) {
        		sortRules.add(new SortRule(2, "batch", "DESC"));//expireDate
        	} else if (TurnOverMode.FIFO_VALIDDATE.equals(turnOverMode)) {
        		sortRules.add(new SortRule(1, "batch", "ASC"));//expireDate
        	} else if (TurnOverMode.LIFO_VALIDDATE.equals(turnOverMode)) {
        		sortRules.add(new SortRule(1, "batch", "DESC"));//expireDate
        	} 
        }
       	//参考库位编号顺序排列,保证一个库位的库存在一起
       	sortRules.add(new SortRule(3, "locationIndex", "ASC"));
       	sortRules.add(new SortRule(4, "locationCode", "ASC"));
        //构造排序Chain
        ComparatorChain chain =  new ComparatorChain();
        for (SortRule sortRule : sortRules) {
            if (sortRule.getSortMethod().equals("DESC")) {
                chain.addComparator(new ReverseComparator(
					new BeanComparator(sortRule.getSortKey())));
            } else {
                chain.addComparator(
					new BeanComparator(sortRule.getSortKey()));
            }
        }
        
        //排序处理
        Collections.sort(inventoryWraps,chain);
       
        //将托盘库存排到非托盘库存前
        List<Inventory> tempInvs1 = new ArrayList<Inventory>();
        List<Inventory> tempInvs2 = new ArrayList<Inventory>();
        for(InventoryWrap inventoryWrap : inventoryWraps){
        	if(inventoryWrap.getInventory().getLP() == null){
        		tempInvs2.add(inventoryWrap.getInventory());
        	}else{
        		tempInvs1.add(inventoryWrap.getInventory());
        	}
        }
        tempInvs1.addAll(tempInvs2);
        return tempInvs1;
    }
	//-----------------------------SortRule.java------------------
	public class SortRule {
		private int sortIndex;
		private String sortKey;
		private String sortMethod;
	}
	//-----------------------------InventoryWrap.java-------------
	public class InventoryWrap{
		private Inventory inventory;
		private Date storageDate;
		private Date productionDate;//生产日
		private Date expireDate;//失效日
		private Integer convertFigure;
		private Integer locationIndex;//库位排序号
		private String locationCode;
		private String locationStatus;
		private double locationUsedRate;
		private Integer lpIndex;
		private Long locationId;
		private double avaliableQuantity;
		private String batch;
	}

 使用案例2：

	private List<OperatingDailyTemp> sortByRule(List<InventoryWrap> inventoryWraps) {
		//收集排序规则
        List<SortRule> sortRules = new ArrayList<SortRule>();
    	sortRules.add(new SortRule(1, "itemCode", "ASC"));
 		sortRules.add(new SortRule(2, "batch", "ASC"));
 		 //构造排序Chain
         ComparatorChain chain =  new ComparatorChain();
         for (SortRule sortRule : sortRules) {
             if (sortRule.getSortMethod().equals("DESC")) {
                 chain.addComparator(new ReverseComparator(
					new BeanComparator(sortRule.getSortKey())));
             } else {
                 chain.addComparator(
					new BeanComparator(sortRule.getSortKey()));
             }
         }
         //排序处理
        Collections.sort(inventoryWraps,chain);
        
        List<OperatingDailyTemp> tempInvs = 
			new ArrayList<OperatingDailyTemp>();
        for(InventoryWrap inventoryWrap : inventoryWraps){
        	tempInvs.add(inventoryWrap.getTemp());
        }
        return tempInvs;
    }
	//------------------InventoryWrap.java----
	public class InventoryWrap{
		private OperatingDailyTemp temp;
		private String itemCode;
		private String batch;
	}
	//----------------SortRule.java----
	public class SortRule {
		private int sortIndex;
		private String sortKey;
		private String sortMethod;
	}