Заказать массив на основе множественного подключения

Question

Это мой экшн

public class SomeVO {

    private String name;        
    private String usageCount;
    private String numberofReturns;
    private String trendNumber;
    private String nonTrendNumber;
    private String trendType;
    private String auditType;
    public SomeVO(String name,String usageCount,String numberofReturns,String trendNumber,String nonTrendNumber,String trendType,String auditType){
        this.name = name;
        this.usageCount = usageCount;
        this.numberofReturns = numberofReturns;
        this.trendNumber = trendNumber;
        this.nonTrendNumber = nonTrendNumber;
        this.trendType = trendType;
        this.auditType = auditType;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getUsageCount() {
        return usageCount;
    }
    public void setUsageCount(String usageCount) {
        this.usageCount = usageCount;
    }
    public String getNumberofReturns() {
        return numberofReturns;
    }
    public void setNumberofReturns(String numberofReturns) {
        this.numberofReturns = numberofReturns;
    }
    public String getTrendNumber() {
        return trendNumber;
    }
    public void setTrendNumber(String trendNumber) {
        this.trendNumber = trendNumber;
    }
    public String getNonTrendNumber() {
        return nonTrendNumber;
    }
    public void setNonTrendNumber(String nonTrendNumber) {
        this.nonTrendNumber = nonTrendNumber;
    }
    public String getTrendType() {
        return trendType;
    }
    public void setTrendType(String trendType) {
        this.trendType = trendType;
    }
    public String getAuditType() {
        return auditType;
    }
    public void setAuditType(String auditType) {
        this.auditType = auditType;
    }
}

Вот мои ценности

List<SomeVO> myList = new ArrayList<SomeVO>();
        SomeVO some = new SomeVO("A","0","0","123","123","Trend","AuditX");
        myList.add(some);
        some = new SomeVO("B","1","1","234","234","Non trend","AuditX");
        myList.add(some);
        some = new SomeVO("C","0","2","345","345","Trend","AuditX");
        myList.add(some);
        some = new SomeVO("D","2","3","546","546","Trend","AuditX");
        myList.add(some);
        some = new SomeVO("E","2","4","678","678","Non trend","AuditX");
        myList.add(some);
        some = new SomeVO("F","0","0","123","123","Non trend","AuditA");
        myList.add(some);
        some = new SomeVO("G","0","0","123","123","Trend","AuditB");
        myList.add(some);

Вот мой компаратор

public String currentAudit = "AuditX";
public class AuditComparator implements Comparator<SomeVO> {

        @Override
        public int compare(SomeVO o1, SomeVO o2) {
            if(currentAudit.equalsIgnoreCase(o1.getAuditType()) && currentAudit.equalsIgnoreCase(o2.getAuditType())) {
                int value1 = o2.getUsageCount().compareTo(o1.getUsageCount());
                if (value1 == 0) {
                    int value2 = o1.getNumberofReturns().compareTo(o2.getNumberofReturns());
                    if(o1.getTrendType().equalsIgnoreCase("Trend") && o2.getTrendType().equalsIgnoreCase("Trend")) {
                        if (value2 == 0) {
                            return o1.getTrendNumber().compareTo(o2.getTrendNumber());
                        } else {
                            return value2;
                        }
                    } else {
                        if (value2 == 0) {
                            return o1.getNonTrendNumber().compareTo(o2.getNonTrendNumber());
                        } else {
                            return value2;
                        }
                    }
                }
                return value1;
            } else {
                return 1;
            }

        }
    }

Я пытаюсь сортировать VO на основе следующих условий

1. Первый только набор значений currentAudit должен быть принят во внимание, т.е. AuditX

   а) тогда он должен быть отсортирован по количеству использования в порядке убывания

   б) если найден тот же счетчик использования, он должен быть отсортирован по счетчику возврата в порядке возрастания

   c) если счетчик возвратов одинаковый, то он должен проверить наличие тренда: если trendType ="Trend", то он должен сортироваться по номеру тренда, в противном случае - по номеру без тренда.

2. тогда он должен рассмотреть остальные все AuditType и отсортированные по условию a), b), c) как currentAudit. Я попытался достичь этого, и в результате я получил только вышеупомянутый компаратор. Ожидаемый результат: D, A, C, E, F, G. Но я получаю G,F,D,E,B,A,C. Пожалуйста, помогите мне обновить компаратор выше.

Answer 1

Я решил это, разделив фактический список на 2 списка на основе AuditX и оставив в другом списке. Затем использовали приведенный ниже компаратор один за другим, а затем объединили в список результатов. Работает хорошо.

for(SomeVO some:myList) {
            if(some.getAuditType().equalsIgnoreCase("AuditX")) {
                auditX.add(some);
            } else {
                auditY.add(some);
            }
        }
        Collections.sort(auditX, new AuditComparator());            
        Collections.sort(auditY, new AuditComparator());

    public class AuditComparator implements Comparator<SomeVO> {

            @Override
            public int compare(SomeVO o1, SomeVO o2) {
                int value1 = o2.getUsageCount().compareTo(o1.getUsageCount());
                 if (value1 == 0) {
                        int value2 = o1.getNumberofReturns().compareTo(o2.getNumberofReturns());
                        if (value2 == 0) {
                            return (o1.getTrendType().equalsIgnoreCase("Trend") && o2.getTrendType().equalsIgnoreCase("Trend")) ?
                                    o1.getTrendNumber().compareTo(o2.getTrendNumber()):o1.getNonTrendNumber().compareTo(o2.getNonTrendNumber());
                        } else {
                            return value2;
                        }            
            }
                return value1;
        }

Answer 2

Возвращение 1 в нижней части компаратора создает ошибку. Компаратор должен возвращать только 1, если второй элемент больше первого, но если они отличаются, вы всегда возвращаете 1, поэтому самые первые критерии сортировки будут беспорядочными.

   // a helper for case insensitive comparison
   private int compareIgnoreCase(String o1,String o2) {
       return o1.toLowercase.compareTo(o2.toLowercase());
   }

   @Override
    public int compare(SomeVO o1, SomeVO o2) {
        int result=compareIgnoreCase(o1.getAuditType(),o2.getAuditType());
        if (result==0) {
            // we need to go to the 2nd criteria
            result=o2.getUsageCount().compareTo(o1.getUsageCount());
        }
        if (result==0) {
            // ok, 1st and 2nd criteria was the same, go to the 3rd             
          result=o1.getNumberofReturns().compareTo(o2.getNumberofReturns());
        }
        if (result==0) {
            // check trends
            ...
        }
        return result;
    }

Я обнаружил, что такое представление нескольких критериев сравнения значительно облегчает выполнение кода. Сначала мы делаем наивысший приоритет сравнения и продолжаем дальнейшие сравнения, если предыдущие сравнения вернули, что два элемента одинаковы (т.е. результат по-прежнему равен нулю).

Если вам нужно выполнить сортировку по убыванию на каком-то уровне, просто введите -, например:

 Результат =-o1.something.compareTo(o2.something) 

Хорошей идеей будет иметь только одну точку выхода в методе (это также облегчает отслеживание происходящего).

Answer 3

Ваш компаратор не соответствует простому условию: он не является лицом без гражданства. Следующее всегда должно быть правдой: A>B => B<A, В вашем случае в некоторых сценариях A>B and B>A,