집계 도구의 일반 구현

Question

집계 가능한 모든 개체를 집계 할 수있는 클래스 CommonAggregator를 만들고 있습니다.

public interface Aggregatable<T> { 
    public void addFieldValue(T t, AggregationField<T> field); 
} 

public class Charges implements Aggregatable<Charges>{ 

//privat fields 
//Getter and Setters 

    @Override 
    public void addFieldValue(Charges Charges, AggregationField<Charges> field){ 
     if(ChargeDetailAggregationField.TYPE1 == field){ 
      Type1 += Charges.getType1(); 
     }else if(ChargeDetailAggregationField.TYPE2 == field){ 
      Type2 += Charges.getType2(); 
     }else if(ChargeDetailAggregationField.TYPE3 == field){ 
      Type3 += Charges.getType3(); 
     } 
    } 
} 

public class CommonAggregator<T extends Aggregatable<T>> { 

    private static enum AggregationOperation { 
     SUM, MAX, MIN, AVG; 
    } 

    private AggregationField<T>[] fieldsForSum; 
    private AggregationField<T>[] fieldsForMax; 
    private AggregationField<T>[] fieldsForMin; 
    //private AggregationField groupByField = null; 

    public CommonAggregator<T> sum(AggregationField<T>... fields){ 
     this.fieldsForSum = fields; 
     return this; 
    } 

    public CommonAggregator<T> max(AggregationField<T>... fields){ 
     this.fieldsForMax = fields; 
     return this; 
    } 

    public CommonAggregator<T> min(AggregationField<T>... fields){ 
     this.fieldsForMin = fields; 
     return this; 
    } 

    private <T> void performOperation(AggregationOperation op,AggregatedResponse<T> aggregatedDetails,List<T> aggregatables,AggregationField<T>... fields){ 
     Aggregatable<T> aggregatedResponse = (Aggregatable<T>) getNewInstance(); 
     T response = null; 
     for(AggregationField<T> field:fields){ 

      if(op == AggregationOperation.MAX){ 
       response = max(field,aggregatables);//Compilation Err 
      }else if(op == AggregationOperation.MIN){ 
       response = min(field,aggregatables);//Compilation Err 
      }else if(op == AggregationOperation.SUM){ 
       response = sum(field,aggregatables);//Compilation Err 
      } 

      aggregatedResponse.setFieldValue(response, field); 

      if(op == AggregationOperation.MAX){ 
       aggregatedDetails.setMax(aggregatedResponse); 
      }else if(op == AggregationOperation.MIN){ 
       aggregatedDetails.setMin(aggregatedResponse); 
      }else if(op == AggregationOperation.SUM){ 
       aggregatedDetails.setSum(aggregatedResponse); 
      } 
     } 
    } 

    private T max(AggregationField<T> field,List<T> aggregatables){ 
     CommonComparator<T> comparator = new CommonComparator<T>(SortOrder.ASCENDING, field); 
     return Collections.max(aggregatables, comparator); 
    } 

    private T min(AggregationField<T> field,List<T> aggregatables){ 
     CommonComparator<T> comparator = new CommonComparator<T>(SortOrder.ASCENDING, field); 
     return Collections.min(aggregatables, comparator); 
    } 

    private T sum(AggregationField<T> field,List<T> listOfAggregatables){ 
     T aggregatable = listOfAggregatables.get(0); 

     for(T response :listOfAggregatables.subList(1, listOfAggregatables.size())){ 
      aggregatable.addFieldValue(response, field); 
     } 
     return aggregatable; 
    } 

    public AggregatedResponse<T> aggregate(List<T> aggregatables){ 

     AggregatedResponse<T> aggregatedDetails = new AggregatedResponse<T>(); 
     if(fieldsForMax != null) 
      performOperation(AggregationOperation.MAX,aggregatedDetails,aggregatables,fieldsForMax); 
     if(fieldsForMin != null) 
      performOperation(AggregationOperation.MIN,aggregatedDetails,aggregatables,fieldsForMin); 
     if(fieldsForSum != null) 
      performOperation(AggregationOperation.SUM,aggregatedDetails,aggregatables,fieldsForSum); 

     return aggregatedDetails; 
    } 

    public <E> Map<E,List<T>> groupBy(AggregationField<T> fieldName, List<T> listOfAggregatable){ 
     Map<E,List<T>> groupedList = new HashMap<E,List<T>>(); 

     for(T t:listOfAggregatable){ 
      List<T> subList = null; 

      E fieldValue = (E)t.getFieldValue(fieldName); 
      if((subList = groupedList.get(fieldValue)) != null){ 
       subList.add(t); 
      }else{ 
       subList = new ArrayList<T>(); 
       subList.add(t); 
       groupedList.put(fieldValue,subList); 
      } 
     } 

     return groupedList; 
    } 

    public <E> Map<E,AggregatedResponse<T>> groupByWithAggregation(AggregationField<T> fieldName, List<T> listOfAggregatable){ 
     //groupByField = fieldName; 
     Map<E, List<T>> groupedByList = groupBy(fieldName, listOfAggregatable); 
     Map<E,AggregatedResponse<T>> mapOfAggregatedDetails = new HashMap<E, AggregatedResponse<T>>(); 
     for(E key : groupedByList.keySet()){ 
      mapOfAggregatedDetails.put(key, aggregate(groupedByList.get(key))); 
     } 
     return mapOfAggregatedDetails; 
    } 

    : 
} 

이것은 완전한 코드가 아닙니다.

여기에서 AggregationField는 집계 할 수있는 집계 가능 클래스의 필드를 알려줍니다.

문제 :

맥스(), 분(), 및 performOperation의 합()

있어서 최대 (AggregationField < T> 목록 < 호출시 저는 followinf 에러에 직면했다 타입 CommonAggregator < T>에서 T는>() 인수에 대한 AggregationField < T> 목록 < T>)

편집 적용되지 않습니다 : 나는 @Mikhail 제안 후 원래의 코드와 질문을 수정했습니다.

나는 generics가 좋지 않다. 그리고 제네릭에서만 뭔가 잘못하고있는 것 같아요.

Answer 1

public interface AggregationField <T> 
{ 
    // ... 
} 

public interface Aggregatable <T> 
{ 
    public void addFieldValue (T t, AggregationField <T> field); 
} 

public class Charges implements Aggregatable <Charges> 
{ 
    @Override 
    public void addFieldValue (
     Charges Charges, AggregationField <Charges> field) 
    { 
     // ... 
    } 
} 

public class CommonAggregator <T extends Aggregatable <T>> { 
    private T sum (
     AggregationField <T> field, 
     List <? extends T> listOfAggregatables) 
    { 
     T aggregatable = listOfAggregatables.get(0); 

     for (T response: listOfAggregatables.subList (1, listOfAggregatables.size())){ 
      aggregatable.addFieldValue(response, field); 
     } 

     return aggregatable; 
    } 
}