java.util.ArrayList無法轉換為java.lang.Comparable

Question

我有UniversalComparator，它完成了所有與排序有關的任務，它使用反射API來識別方法名稱和調用目標。

現在發生的是，我需要對sites進行排序，以前是使用"name"對sites進行排序的，現在發生的是，用戶需要以每月，每季度，每半年和每年的頻率上載文檔。

需求

如果未以任何頻率上載文檔，則該數據以white表示，其余的塊均以red 。

現在有六個SITES，第一個站點只有一個白塊，第二個站點沒有白塊。 第三個站點沒有白塊四個有三個白塊第五個有三個白塊第六個有三個白塊

所以計數是1 0 0 3 3

現在我做了，我創建了一個ArrayList of Integer並存儲了所有計數，現在我需要代表該計數對SITE Block的列表進行排序，所以它應該像

0 0 1 3 3

碼

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

反思是一種非常糟糕的方法。 您在此代碼中絕對沒有類型安全性。 您不能保證實際上存在一個使用您提供的名稱作為字符串的方法。 您不能保證不接受任何參數。 您不知道它將引發什么異常。

如果您使用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現在將無法使用ClassCastException 。