Java --- Math类与统计工具类

本文的核心内容：Java里Math类的常用方法，常用统计数据工具类。

---

 

这个工具类位于java.util包下。

下面这些常用的方法需要我们掌握。

        Math类常用方法：
        1.abs()   绝对值
        2.sqrt()  开平方根
        3.cbrt()  开立方根
        4.max(a,b)  求a,b中最大值
        5.min(a,b)  求a,b中最小值
        6.hypot(x,y)      计算(x的平方+y的平方)的平方根
        7.pow(a,b)        计算a的b次方
        8.Math.random()   取得一个大于或者等于0.0小于不等于1.0的随机数[0,1)

在公司做项目运到一些统计数据的指标，比如求和，平均数，方差，标准差，四分数，中位数等等。我就把这些方法封装了一个工具类。

import java.util.Arrays;
import java.util.List;

/**
 * @author Maps
 * @time 2019-05-01
 * 数学统计工具
 */

public final class MathUtil {
    /**
     * 计算集合的和   
     */
    public final static Double listSum(List list) {
        Double sum = new Double(0);
        for (Object o : list) {
            if (o instanceof Integer) {
                Integer number = (Integer) o;
                sum += number;
            } else {
                Double number = (Double) o;
                sum += number;
            }
        }
        return sum;
    }

    /**
     * 计算集合的平均值
     */
    public final static Double listAvg(List list) {
        return listSum(list) / list.size();
    }

    /**
     * 计算集合的方差
     */
    //方差s^2=[(x1-x)^2 +...(xn-x)^2]/n
    public final static Double listVariance(List list) {
        int size = list.size();
        double avg = listAvg(list);
        double variance = 0;

        for (Object o : list) {
            if (o instanceof Integer) {
                Integer number = (Integer) o;
                variance += (number - avg) * (number - avg);
            } else {
                Double number = (Double) o;
                variance += (number - avg) * (number - avg);
            }
        }

        return variance / size;
    }

    /**
     * 计算标准差     标准差=方差开平方根
     */
    public final static Double listStandardDiviation(List list) {
        return Math.sqrt(listVariance(list));
    }

    /**
     * 计算中位数   ---以数组的维度做为参数
     */
    public final static Double midValue(int[] numbers) {
        Arrays.sort(numbers);
        double mid = 0;
        int size = numbers.length;
        if (size % 2 == 1) {
            mid = numbers[(size - 1) / 2];
        } else {
            //加0.0是为了把int转成double类型，否则除以2会算错
            mid = (numbers[(size / 2 - 1)] + numbers[(size / 2)] + 0.0) / 2;
        }
        return mid;
    }

    /*
     * 中位数   方法重载   double
     * */
    public final static Double midValue(double[] numbers) {
        Arrays.sort(numbers);
        double mid = 0;
        int size = numbers.length;
        if (size % 2 == 1) {
            mid = numbers[(size - 1) / 2];
        } else {
            //加0.0是为了把int转成double类型，否则除以2会算错
            mid = (numbers[(size / 2 - 1)] + numbers[(size / 2)]) / 2;
        }
        return mid;
    }

    /**
     * 求极差
     */
    public static Double range(double[] numbers) {
        if (numbers == null) {
            throw new java.lang.NumberFormatException();
        }
        double max = Double.MIN_VALUE;
        double min = Double.MAX_VALUE;
        for (int i = 0; i < numbers.length; i++) {
            max = Math.max(max, numbers[i]);
            min = Math.min(min, numbers[i]);
        }
        // return max - min;
        return max - min;
    }

    /**
     * 求极差  方法重载
     */
    public static Integer range(int[] numbers) {
        if (numbers == null) {
            throw new java.lang.NumberFormatException();
        }
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < numbers.length; i++) {
            max = Math.max(max, numbers[i]);
            min = Math.min(min, numbers[i]);
        }
        // return max - min;
        return max - min;
    }

    /**
     * 四分位数
     */
    public static double[] quartile(double[] items) {
        if (items == null || items.length == 0) return null;
        double[] result = new double[3];
        int length = items.length;
        Arrays.sort(items);

        if (length % 2 == 0) {//偶数
            result[1] = 1.0 * (items[length / 2 - 1] + items[length / 2]) / 2;
        } else {//奇数
            result[1] = 1.0 * items[(length + 1) / 2 - 1];
        }

        if (length % 4 == 0) {
            result[0] = 1.0 * (items[length / 4 - 1] + items[length / 4]) / 2;
            result[2] = 1.0 * (items[3 * length / 4 - 1] + items[3 * length / 4]) / 2;
        } else {
            result[0] = 1.0 * items[length / 4];
            result[2] = 1.0 * items[3 * length / 4];
        }
        return result;
    }


}