java 概率工具类，比如随机立减优惠概率

开发中经常会计算概率。比如支付场景，支付100元立减0.1~1元，要在其中设置不同的概率，比如设置90%是立减0.1元，这个时候就需要用到概率工具类。

废话少说，看代码，直接用：

 

import java.util.*;
import java.util.Map.Entry;


/**
 * 随机数工具类
 *
 * @author gogym
 * @version 2017年8月30日
 * @see ProbUtil
 * @since
 */
public final class ProbUtil {

    public static void main(String[] args) {

        Integer a = 0, b = 0, c = 0;

        for (int j = 0; j < 10000; j++) {

            Map<Integer, Double> m = new HashMap<Integer, Double>();
            m.put(10, 10.0);
            m.put(20, 30.0);
            m.put(30, 60.0);

            Integer result = getRand(m);
            switch (result) {
                case 10:
                    a++;
                    break;
                case 20:
                    b++;
                    break;
                case 30:
                    c++;
                    break;
            }

        }

        System.out.println("1的次数：" + a + "     2的次数：" + b + "     3的次数：" + c);
        System.out.println("exit");

    }

    private final static Random random = new Random();

    /**
     * 获取随机数
     *
     * @param min
     * @param max
     * @return Integer, null: when max < min
     */
    public static final Integer rand(int min, int max)
    {
        int tmp = max - min;
        if (tmp < 0)
        {
            return null;
        }
        else if (tmp == 0)
        {
            return min;
        }
        else
        {
            return random.nextInt(tmp + 1) + min;
        }
    }

    /**
     * 获取概率事件，几率最多支持3位小数
     *
     * @param map 参数举例: Map(1=>20.1, 2=>29.9, 3=>50), 则20.1%几率返回1, 29.9%返回2, 50%返回3
     * @return 返回键值
     */
    public static final <T> T getRand(Map<T, Double> map) {
        // 放大位数
        int multiple = 1000;
        // 求和
        int sum = 0;
        Iterator<Entry<T, Double>> iter = map.entrySet().iterator();
        while (iter.hasNext()) {
            Entry<T, Double> entry = iter.next();
            Double v = entry.getValue();
            sum += v * multiple;
        }

        if (sum <= 0) {
            return null;
        }

        // 产生0-sum的整数随机
        int luckNum = random.nextInt(sum) + 1;
        int tmp = 0;
        iter = map.entrySet().iterator();
        while (iter.hasNext()) {
            Entry<T, Double> entry = iter.next();
            Double v = entry.getValue();
            tmp += v * multiple;
            if (luckNum <= tmp) {
                return entry.getKey();
            }
        }
        return null;
    }

    /**
     * 从集合中随机一个元素
     *
     * @param <T>
     * @param map
     * @return
     * @date: 2016年4月12日 下午1:18:08
     */
    public static final <T> T getRand(Collection<T> map) {
        // 放大位数
        int multiple = 1000;
        // 求和
        int sum = map.size() * multiple;

        if (sum <= 0) {
            return null;
        }
        // 产生0-sum的整数随机
        int luckNum = random.nextInt(sum) + 1;
        int tmp = 0;
        for (T one : map) {
            tmp += multiple;
            if (luckNum <= tmp) {
                return one;
            }
        }
        return null;
    }

    /**
     * 获取概率事件
     *
     * @param wildsArr 字符数组
     * @param num      返回结果个数
     * @return 选中结果（会有重复的）
     */
    public static final int[] getRandByStrArray(int[] wildsArr, int num) {
        int[] ret = new int[num];
        int len = wildsArr.length;
        for (int i = 0; i < num; i++) {
            int luckNum = random.nextInt(len);
            System.arraycopy(wildsArr, luckNum, ret, i, 1);
        }
        return ret;
    }

    /**
     * 由概率随机是否触发
     *
     * @param chance 0.00 - 100.00
     * @return boolean
     */
    public static final boolean isLuck(double chance) {
        // chance = 50.0;// 测试：50%成功
        double chanceInt = chance * 100;
        return ProbUtil.rand(1, 10000) <= chanceInt;
    }

    /**
     * 获取两个数之间的随机数,得出的值符合正态分布
     *
     * @param min    最小值
     * @param max    最大值
     * @param factor 调整曲线参数
     * @return
     */
    public static final int gaussianRand(int min, int max, int factor) {
        if (min > max) {
            return 0;
        }
        int middle = (int) Math.ceil((min + max) / 2.0);
        int in = max - middle;
        factor = factor < 0 ? 0 : factor;
        LinkedHashMap<Integer, Double> map = new LinkedHashMap<Integer, Double>();
        for (int i = min; i <= max; i++) {
            if (i == middle) {
                map.put(i, (double) in);
            } else {
                double tmp = Math.abs(in - Math.abs(middle - i));
                tmp = tmp <= 0 ? 1 : tmp;
                tmp = factor > 0 ? tmp * (1 + factor / 100.0) : tmp;
                tmp = tmp > in ? in : tmp;
                map.put(i, tmp);
            }
        }
        return ProbUtil.getRand(map);
    }

    /**
     * 获取两个数之间的随机数,得出的值符合正态分布
     *
     * @param min 最小值
     * @param max 最大值
     * @return
     */
    public static final int gaussianRand(int min, int max) {
        return gaussianRand(min, max, 0);
    }

    /**
     * 在一个范围内随机一定量的的数值
     *
     * @param start
     * @param end
     * @param num
     * @return
     * @author tangyangbo 2014-1-21
     */
    public static List<Integer> randomList(int start, int end, int num) {
        List<Integer> reslut = new ArrayList<Integer>();
        if (start >= end) {
            return reslut;
        }
        // 返回所有可能,打乱顺序
        if ((end - start) <= num) {
            for (int i = start; i < end; i++) {
                reslut.add(i);
            }
            Collections.shuffle(reslut);
            return reslut;
        }
        int temp = 0;
        for (int i = 0; i < num && i < (end - start); ) {
            temp = rand(start, end);
            if (!reslut.contains(temp)) {
                reslut.add(temp);
                i++;
            }
        }
        return reslut;
    }

    /**
     * 在一组数据里面随机几个值
     *
     * @param <T>
     * @param array 随机的源数据
     * @param num   获取数据个数
     * @return
     * @author tangyangbo 2015年11月23日
     */
    public static <T> List<T> getRandByArray(T[] array, int num) {
        List<T> reslut = new ArrayList<T>();
        List<T> temp = new ArrayList<T>();
        for (T v : array) {
            temp.add(v);
        }

        if (num >= temp.size()) {
            return temp;
        }

        for (int i = 0; i < num; i++) {
            int index = rand(0, temp.size() - 1);
            T value = (T) temp.get(index);
            if (!reslut.contains(value)) {
                temp.remove(index);
                reslut.add(value);
            }
        }
        return reslut;
    }

}