統計計算

Question

是否有任何內置的庫，我可以用它來計算中值在Java？

我正在爲其他統計函數使用apache.commons.math，但中位數無處可查。

謝謝

Answer 1

您使用的是哪個版本的Apache Commmons Math？至少在2.1以上的時候有一箇中級班（我不太確定老班）。您可以將其用作：

Median median = new Median(); 
median.evaluate(values); 

Answer 2

把所有的數字到一個列表，列表進行排序，取中間值（或平均兩個中間值的大小均勻）。無需計算

Answer 3

嘗試使用Median對象。

Answer 4

將值獲取到List對象中。假設這些值是整數，並且該列表被稱爲「值」。然後

List<Integer> values; 
... populate values ... 
Collections.sort(values); 
int median; 
int midpoint=values.size()/2; 
if (values.size()%2==1) 
    median=values.get(midpoint+1).intValue(); 
else 
    median=(values.get(midpoint).intValue()+values.get(midpoint+1).intValue())/2; 

如果值的數量很大，比如在數百或更多，那麼與mod-2混合可能在技術上是正確的但是多餘的。

也許有一種更有效的方法來做到這一點 - 排序是很大的列表上很慢 - 但這是行得通的。

哦，你真的應該檢查一個零條目列表。也許我錯過了其他邊界條件。

Answer 5

從「太多的時間啓動，我的雙手」部門：這裏是一個小MedianGenerator類：

/** 
* Methods to calculate the median value of a supplied {@link List}. 
*/ 
public final class MedianGenerator{ 

    private MedianGenerator(){ 
    } 

    /** 
    * Calculate the median of a supplied list. 
    * <ol> 
    * <li>A copy will be generated</li> 
    * <li>this copy will be sorted with the supplied comparator</li> 
    * <li>the median will be calculated, using the supplied averageCalculator 
    * for collections with an even number of items</li> 
    * </ol> 
    * 
    * @param data 
    * @param comparator 
    * @param averageCalculator 
    * @return the median 
    */ 
    public static <T> T calculateMedian(final List<T> data, 
     final Comparator<? super T> comparator, 
     final AverageCalculator<T> averageCalculator){ 
     final List<T> copy = new ArrayList<T>(data); 
     Collections.sort(copy, comparator); 
     return doCalculateMedian(data, averageCalculator); 

    } 

    /** 
    * Calculate the median of a supplied list. 
    * <ol> 
    * <li>A copy will be generated</li> 
    * <li>this copy will be sorted with the supplied comparator</li> 
    * <li>the median will be calculated, using the {@link #ALWAYS_FIRST} {@link AverageCalculator} 
    * for collections with an even number of items</li> 
    * </ol> 
    * 
    * @param data 
    * @param comparator 
    * @return the median 
    */ 
    @SuppressWarnings("unchecked") 
    public static <T> T calculateMedian(final List<T> data, 
     final Comparator<? super T> comparator){ 
     return calculateMedian(data, comparator, (AverageCalculator<T>) ALWAYS_FIRST); 
    } 

    /** 
    * Calculate the median of a supplied list. 
    * <ol> 
    * <li>A copy will be generated</li> 
    * <li>this copy will be sorted using natural ordering</li> 
    * <li>the median will be calculated, using the {@link #ALWAYS_FIRST} {@link AverageCalculator} 
    * for collections with an even number of items</li> 
    * </ol> 
    * 
    * @param data 
    * @return the median 
    */ 
    @SuppressWarnings("unchecked") 
    public static <T extends Comparable<? super T>> T calculateMedian(final List<T> data){ 
     return calculateMedian(data, (AverageCalculator<T>) ALWAYS_FIRST); 
    } 

    /** 
    * Calculate the median of a supplied list. 
    * <ol> 
    * <li>A copy will be generated</li> 
    * <li>this copy will be sorted using natural ordering</li> 
    * <li>the median will be calculated, using the supplied averageCalculator 
    * for collections with an even number of items</li> 
    * </ol> 
    * 
    * @param data 
    * @param averageCalculator 
    * @return the median 
    */ 
    public static <T extends Comparable<? super T>> T calculateMedian(final List<T> data, 
     final AverageCalculator<T> averageCalculator){ 
     final List<T> copy = new ArrayList<T>(data); 
     Collections.sort(copy); 
     return doCalculateMedian(copy, averageCalculator); 
    } 

    private static <T> T doCalculateMedian(final List<T> sortedData, 
     final AverageCalculator<T> averageCalculator){ 
     T result; 
     if(sortedData.isEmpty()){ 
      result = null; 
     } else{ 
      final int size = sortedData.size(); 
      if(size % 2 == 0){ 
       result = 
        averageCalculator.getAverage(sortedData.get(size/2 - 1), 
         sortedData.get(size/2)); 
      } else{ 
       result = sortedData.get(size/2 - 1); 
      } 

     } 
     return result; 
    } 

    /** 
    * Generic accessor method for {@link #ALWAYS_FIRST}. 
    */ 
    @SuppressWarnings("unchecked") 
    public static <T> AverageCalculator<T> alwaysFirst(){ 
     return ALWAYS_FIRST; 
    } 

    /** 
    * {@link AverageCalculator} implementation that always returns the lower 
    * bound unchanged. 
    */ 
    @SuppressWarnings("rawtypes") 
    public static final AverageCalculator ALWAYS_FIRST = 
     new AverageCalculator(){ 

      @Override 
      public Object getAverage(final Object first, final Object second){ 
       return first; 
      } 

     }; 

    /** 
    * When there is an even number of items, this interface is used to generate 
    * the average between the two middle items. 
    */ 
    public static interface AverageCalculator<E> { 

     E getAverage(E first, E second); 
    } 

}