Заказать ArrayList на основе множественного соединения

Question

Это мой VO

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

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

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

   с), если подсчитывать же возвращения, то он должен проверить на trendType, если trendType = «Тренд», то он должен разобраться с номером Trend в противном случае не Номер тренда.

2. тогда он должен рассмотреть возможность отдыха всех аудиторских типов и отсортировать их с помощью a), b), c) состояние как currentAudit. Я попытался это сделать, и i закончил работу только с компаратором. Ожидаемый результат: 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

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

Answer 3

Возврат 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; 
    } 

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

В случае, если вам нужно сделать сортировку нисходящая на каком-то уровне, просто положить -, например:

 result=-o1.something.compareTo(o2.something)

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