手書きコンパレータ

プロジェクトの中でいくつかのデータに対して並べ替えを行う必要があって、比較的に強大な比較器に応用して、感じはやはりとても悪くなくて、コードを貼ります:

public class XXXComparator<E> {
    private final Logger log = Logger.getLogger(XXXComparator.class);

    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void sort(List<E> list, final String method, final String sortType) {
        // list  list  
       // method get 
      // sortType  desc or asc

        Collections.sort(list, new Comparator() {

            public int compare(Object a, Object b) {
                int ret = 0;
                try {
                    Method m1 = ((E) a).getClass().getMethod(method, null);
                    Method m2 = ((E) b).getClass().getMethod(method, null);
                    if (sortType != null && "desc".equals(sortType)) {
                        ret = m2.invoke(((E) b), null).toString()
                                .compareTo(m1.invoke(((E) a), null).toString());
                    } else {
                        ret = m1.invoke(((E) a), null).toString()
                                .compareTo(m2.invoke(((E) b), null).toString());
                    }
                } catch (NoSuchMethodException e) {
                    log.error(e);
                } catch (InvocationTargetException e) {
                    log.error(e);
                } catch (IllegalAccessException e) {
                    log.error(e);
                }
                return ret;
            }
        });
    }

}

例えばPeopleオブジェクトがあり、name、ageなどの属性があります.
Peopleのリストがあります.nameやage列などのソートが必要です.
はい、そう書いてもいいです.

XXXComparator<People> sortList = new XXXComparator<People>();
String method = "getName"; //or  'getAge'
String orderByType = "desc";
sortList.sort(peopleList, method, orderByType);

これで属性別のソートが可能になります
以上のcomparatorを最適化し,intタイプのデータに上記のメソッドを適用すると問題がある.

public class XXXComparator<E> {
    private final Logger log = Logger.getLogger(XXXComparator.class);

    @SuppressWarnings({ "unchecked", "rawtypes" })
    public void sort(List<E> list, final String methodName, final String sortType) {
        Collections.sort(list, new Comparator() {

            public int compare(Object a, Object b) {
                int ret = 0;
                try {

                    Method method = a.getClass().getMethod(methodName);

                    Object aResult = method.invoke(a);
                    Object bResult = method.invoke(b);

                    if (aResult == null) {
                        return -1;
                    }
                    if (bResult == null) {
                        return 1;
                    }
                    if (aResult instanceof String) {
                        String com1 = "desc".equals(sortType) ? (String) aResult : (String) bResult;
                        String com2 = "desc".equals(sortType) ? (String) bResult : (String) aResult;
                        log.info("aResult= " + aResult + "
bResult= " + bResult);
                        return com1.toLowerCase().compareTo(com2.toLowerCase());

                    }

                    if (aResult instanceof Comparable) {
                        Comparable com1 = "desc".equals(sortType) ? (Comparable) aResult
                                : (Comparable) bResult;
                        Comparable com2 = "desc".equals(sortType) ? (Comparable) bResult
                                : (Comparable) aResult;
                        return com1.compareTo(com2);

                    }

                } catch (NoSuchMethodException e) {
                    log.error(e);
                } catch (InvocationTargetException e) {
                    log.error(e);
                } catch (IllegalAccessException e) {
                    log.error(e);
                }
                return ret;
            }
        });
    }

}