java.util.ArrayList 无法转换为 java.lang.Comparable

Question

我有UniversalComparator，它执行与排序相关的所有任务，它使用反射API来识别方法名称和调用目标。

现在发生的事情是，我需要对网站进行排序，以前是使用“name”排序的，现在发生的事情是，用户需要按频率上传文档月度、季度、半年和年度。

要求

如果文档未以任何频率上传，则该数据以白色颜色表示，其余 block 以红色颜色表示。

目前有六个站点，第一个站点只有一个白色 block 第二个站点没有白色 block 。第三个站点没有白色 block 四有三白 block 第五个有三个白色 block 第六个有三个白色 block

所以计数是10033

现在我做了什么，我创建了一个 Integer 的 ArrayList 并存储所有计数现在我需要代表这个计数对站点 block 列表进行排序，所以它应该像

00133

代码

package com.lear.common.utility;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Comparator;



public class UniversalComparator implements Comparator {

    /**
     * static final int ASCENDING
     */
    public static final int ASCENDING = 1;

    /**
     * static final int DESCENDING
     */
    public static final int DESCENDING = -1;

    /*
     * int for descAscIndicator
     */
    private int descAscIndicator = 1;

    /*
     * String to store method Name
     */
    private String methodName = "toString";

    /**
     * Constructor for UniversalComparator
     * 
     * @param descAscIndicator
     *            int to store descAscIndicator.
     */
    public UniversalComparator(int descAscIndicator) {
        this.descAscIndicator = descAscIndicator;
    }

    /**
     * Constructor for UniversalComparator
     * 
     * @param methodName
     *            : name of method as criteria
     * @param descAscIndicator
     *            : order of sorting
     */
    public UniversalComparator(String methodName, int descAscIndicator) {
        this(descAscIndicator);
        this.methodName = methodName;
    }

    /**
     * This Method compare Two Objects
     * 
     * @param o1
     *            : An Instance of Object.
     * @param o2
     *            : An Instance of Object.
     * @return int
     */
    public int compare(Object o1, Object o2) {
        Object comp1 = null;
        Object comp2 = null;

        try {
            Method o1_Method = (o1.getClass()).getMethod(methodName, null);
            Method o2_Method = (o2.getClass()).getMethod(methodName, null);
            comp1 = o1_Method.invoke(o1, null);
            comp2 = o2_Method.invoke(o2, null);

        } catch (NoSuchMethodException e) {
            throw new RuntimeException("Method does not exist" + e.getMessage());
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Illegal access" + e.getMessage());
        } catch (InvocationTargetException e) {
            throw new RuntimeException("InvocationTargetException"
                    + e.getMessage());
        }
        Comparable c1 = (Comparable) comp1;
        Comparable c2 = (Comparable) comp2;
        return c1.compareTo(c2) * descAscIndicator;
    }

    /**
     * Check for Equality obect
     * 
     * @param obj
     *            : An Instance of Object.
     * @return boolean return true if equal or false if not
     */
    public boolean equals(Object obj) {
        return this.equals(obj);
    }
}

ScoreCardManager.java

List<Integer> naSiteDataList = new ArrayList<Integer>();

public String getComparativeSiteAnalysis(Integer divId, String lang, int selectedYear) {

// PLENTY OF CODE HERE
    int annualDataCount = site.getComparativeColorAnnual().equalsIgnoreCase("White") ? 1 : 0;
                naSiteDataCount = monthlyDataCount + quaterlyDataCount + semiAnnualDataCount + annualDataCount;
                naSiteDataList.add(naSiteDataCount);
                naSiteCounter.add(naSiteDataCount);
                site.setNaSiteCount(naSiteDataList);
                site.setNaSiteCounter(naSiteCounter);
                System.out.println("datacount is" + naSiteDataCount);
            }
          // THIS LINE
            Collections.sort(sites, new UniversalComparator("getNaSiteCount", 1));

Site.java

 public class Site{

// lot of properties

    private List<Integer> naSiteCount;

    public List<Integer> getNaSiteCount() {
            return naSiteCount;
        }

        public void setNaSiteCount(List<Integer> naSiteCount) {
            this.naSiteCount = naSiteCount;
        }

}

Answer 1

反射(reflection)是一种非常糟糕的方法。这段代码中绝对没有类型安全。您无法保证以您提供的字符串名称的方法确实存在。您不能保证它不带任何参数。您不知道它可能会抛出什么异常。

如果您使用 Java 8 plus，那么实现特定的比较器将是微不足道的:

Comparator<Object> comparator = Comparator.comparing(Object::toString);

但是缺乏 Java 8 功能并不是使用反射的理由。

定义一个抽象类:

abstract class AbstractComparator<T, C extends Comparable<? super C>> implements Comparator<T> {
  abstract C toComparable(T object);

  @Override public int compare(T a, T b) {
    return toComparable(a).compareTo(toComparable(b));
  }

  Comparator<T> reverse() {
    return new Comparator<T>() {
      @Override public int compare(T a, T b) {
        return toComparable(b).compareTo(toComparable(a));
      }
    }
  }
}

然后针对您的具体情况实现此操作:

Comparator<Object> comparator = new AbstractComparator<Object, String> {
  @Override String toComparable(Object object) { return object.toString(); }
}.reverse();

如果您正在使用 Guava 或其他带有类似 Function 的类的库，或者很乐意自己定义它，那么您当然可以采用组合方法，而不是使用继承:

Comparator<Object> comparator = new ConcreteComparator<>(new Function<Object, String>() {
  @Override public String apply(Object object) {
    return object.toString();
  }
});

如果您不在比较器或您正在比较的事物周围使用原始类型，则 ClassCastException 现在将是不可能的。