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

缺乏、安全感 2022-11-27 03:12 124阅读 0赞

开发中经常会计算概率。比如支付场景，支付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;
        }
    
    }