利用Comparator对枚举类型进行排序的实现（ComparatorChain、BeanComparator、FixedOrderComparator）

野性酷女 2021-06-24 16:09 174阅读 0赞

# #

## 背景： ##

工作中遇到按照类的某个属性排列，这个属性是个枚举类型（完全是自定义的，没有明显的比较标志），现要按照要求的优先级排列。

如一个苹果类有大小和甜度属性，大小有“特大”，“大”，“中”，“小”，“很小”的等级，甜度有“很甜”，“甜”，“不甜”的等级，现要求你按从小到大的顺序，同时从不甜到甜的顺序进行排列。

## 解决方案： ##

刚开始看到会一头雾水，难道需要用五个数组按大小进行分类，然后继续按照甜度用数组分类，最后进行拼接吗？当然不是。

可以使用ComparatorChain、BeanComparator、FixedOrderComparator实现，通过这三个方法，可以实现arraylist按照多个枚举类型进行复合排序。

如下：

String daXiaoOrder[] = {"很小","小","中","大"，"特大"};
            String tianDuOrder[] = {"不甜","甜","很甜"}
            ComparatorChain comparatorChain = new ComparatorChain();
            FixedOrderComparator fixedOrderComparator1 = new FixedOrderComparator(daXiaoOrder);
            FixedOrderComparator fixedOrderComparator2 = new FixedOrderComparator(tianDuOrder); 
             //daXiao 和 tianDu 是Apple类的成员变量   
            comparatorChain.addComparator(new BeanComparator("daXiao",fixedOrderComparator1)); 
            comparatorChain.addComparator(new BeanComparator("tianDu",fixedOrderComparator2));
            Collections.sort(appleList, comparatorChain);

## 深入一点： ##

查看源码ComparatorChain：

//可以往ComparatorChain添加Comparator，同时可以改变reverse为true 为逆序
      public void addComparator(Comparator comparator)
      public void addComparator(Comparator comparator, boolean reverse)
    
      //当ComparatorChain中有多个Comparator时，是进行迭代循环比较的
      Iterator comparators = this.comparatorChain.iterator();

查看源码BeanComparator：

//BeanComparator的构造器
    public BeanComparator(String property) 
    
    public BeanComparator(String property, Comparator<?> comparator)
    
    //它的compare
     public int compare(T o1, T o2) {
          if (this.property == null) {
             return this.internalCompare(o1, o2);
          } else {
             try {
                Object value1 = PropertyUtils.getProperty(o1, this.property);
                Object value2 = PropertyUtils.getProperty(o2, this.property);
                return this.internalCompare(value1, value2);
             } catch (IllegalAccessException var5) {
                throw new RuntimeException("IllegalAccessException: " + var5.toString());
             } catch (InvocationTargetException var6) {
                throw new RuntimeException("InvocationTargetException: " + var6.toString());
             } catch (NoSuchMethodException var7) {
                throw new RuntimeException("NoSuchMethodException: " + var7.toString());
             }
          }
       }
    //internalCompare就是调用自身的comparator
    private int internalCompare(Object val1, Object val2) {
          Comparator c = this.comparator;
          return c.compare(val1, val2);
       }

查看BeanComparator源码可知，BeanComparator比较通用，可以使用自定义Comparator，没有自定义时，也会使用默认的Comparator进行比较。

查看源码fixedOrderComparator：

//构造函数
    public FixedOrderComparator(Object[] items)
    public FixedOrderComparator(List items)
    
    //可以添加排序条件
    public boolean add(Object obj) {
          this.checkLocked();
          Object position = this.map.put(obj, new Integer(this.counter++));
          return position == null;
       }
    
       public boolean addAsEqual(Object existingObj, Object newObj) {
          this.checkLocked();
          Integer position = (Integer)this.map.get(existingObj);
          if (position == null) {
             throw new IllegalArgumentException(existingObj + " not known to " + this);
          } else {
             Object result = this.map.put(newObj, position);
             return result == null;
          }
       } 
    
    //compare函数
    public int compare(Object obj1, Object obj2) {
          this.isLocked = true;
          Integer position1 = (Integer)this.map.get(obj1);
          Integer position2 = (Integer)this.map.get(obj2);
          if (position1 != null && position2 != null) {
             return position1.compareTo(position2);
          } else {
             switch(this.unknownObjectBehavior) {
             case 0:
                if (position1 == null) {
                   return position2 == null ? 0 : -1;
                }
    
                return 1;
             case 1:
                if (position1 == null) {
                   return position2 == null ? 0 : 1;
                }
    
                return -1;
             case 2:
                Object unknownObj = position1 == null ? obj1 : obj2;
                throw new IllegalArgumentException("Attempting to compare unknown object " + unknownObj);
             default:
                throw new UnsupportedOperationException("Unknown unknownObjectBehavior: " + this.unknownObjectBehavior);
             }
          }
       }

查看构造器发现 fixedOrderComparator既可以传入数组也可以是列表。继续查看源码发现其实他也是对"很小","小","中","大"，"特大"，这样的枚举类型进行标号排序的，放在map中，如当比较很小，小的时候，首先根据枚举类型获取相应的position，0和1，只要比较position的大小，就知道了相应的object的大小。

其余的细节以后再说，欢迎大家有问题一起讨论。