精华内容
下载资源
问答
  • java实现随机抢红包

    千次阅读 2018-06-14 10:31:36
    要求:实现参与抢红包人员可以抢到随机金额,每个人必须抢到大于0的金额。 思路:1.生成(总人数-1)个范围在0到总金额的随机数,组成数组arrList; 2.通过冒泡排序按照从小到大排序; 3.将排序后的数组按照...
    要求:实现参与抢红包人员可以抢到随机金额,每个人必须抢到大于0的金额。

       思路:1.生成(总人数-1)个范围在0到总金额的随机数,组成数组arrList;

                 2.通过冒泡排序按照从小到大排序;

                 3.将排序后的数组按照arrList[i+1]-arrList[i]方式取出(总人数-1)个差值,组成一个新数组newArrList

                    (注意:取出的第一个数据为第一个随机数,即arrList[1]-0)

                 4.总金额减去第三步newArrList所有数据之和,得到差值作为newArrList最后一个元素;

                 5.得到一个数组newArrList;

                 6.接收到抽奖请求后,按顺序取newArrList中的值作为该参与者的红包金额。


       思路实现图:(以6个人为例)

    1.生成5个随机数升序排列

    0523466779
    2.随机数后一位减前一位得到差值
    51823211221

       代码实现:

    private static  List<Integer> getMoney(Integer totalMoney,Integer totalPersons){
        Random random = new Random();
        int[] randomNumList = new int[totalPersons-1];
        for(int i=0;i<totalPersons-1;i++){
            Integer randomNum = random.nextInt(totalMoney);
            randomNumList[i] = randomNum;
        }
        int temp = 0;
        for(int i=0;i<randomNumList.length-1;i++){
            for(int j=0;j<randomNumList.length-1-i;j++){
                if(randomNumList[j+1]<randomNumList[j]){
                    temp = randomNumList[j];
                    randomNumList[j] = randomNumList[j+1];
                    randomNumList[j+1] = temp;
                }
            }
        }
        List<Integer> moneyList = new ArrayList<>();
        int total = 0;
        for(int i=0;i<randomNumList.length;i++){
            if(i==0){
                moneyList.add(randomNumList[0]);
                total+=randomNumList[0];
            }else{
                int tempNum = randomNumList[i]-randomNumList[i-1];
                moneyList.add(tempNum);
                total+=tempNum;
            }
        }
        moneyList.add(totalMoney-total);
        return moneyList;
    }
    测试验证:
    public static void main(String[] args){
        List<Integer> aa = getMoney(180,6);
        for(int a : aa){
            System.out.println("抽取红包金额为:"+a+"元");
        }
    }
    测试结果:

    抽取红包金额为:12元
    抽取红包金额为:32元
    抽取红包金额为:43元
    抽取红包金额为:44元
    抽取红包金额为:22元
    抽取红包金额为:27元

    展开全文
  • 新年到,发红包,下面是java 简单实现群主派发红包的功能:具体实现代码如下: 定义用户主类: package com.example.demo.redEnvelopes; import java.math.BigDecimal; /** * 用户主类 */ public class User { ...

    新年到,发红包,下面是java 简单实现群主派发红包的功能:具体实现代码如下:
    定义用户主类:

    package com.example.demo.redEnvelopes;
    
    import java.math.BigDecimal;
    
    /**
     * 用户主类
     */
    public class User {
        // 定义两个私有属性
        private String name;
        private BigDecimal leftMoney;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public BigDecimal getLeftMoney() {
            return leftMoney;
        }
    
        public void setLeftMoney(BigDecimal leftMoney) {
            this.leftMoney = leftMoney;
        }
    
        public User() {
        }
    
        public User(String name, BigDecimal leftMoney) {
            this.name = name;
            this.leftMoney = leftMoney;
        }
    
        // 定义一个查看余额的方法
        public void check() {
            System.out.println("名字:" + name + ",余额为" + leftMoney + "元");
        }
    
    }
    
    

    定义群主类:

    package com.example.demo.redEnvelopes;
    
    import org.apache.commons.compress.utils.Lists;
    
    import java.math.BigDecimal;
    import java.util.List;
    
    /**
     * 定义群主类
     */
    public class Lord extends User{
    
        /**
         * 每个红包总额最小金额
         */
        private static final BigDecimal  MIN = new BigDecimal("0.01");
    
        /**
         * 精度
         */
        private static final int  SCALE = 2;
    
        public Lord() {
        }
    
        public Lord(String name, BigDecimal leftMoney) {
            // super(参数列表) 永远要放到构造方法中的第一条语句中
            super(name, leftMoney);
        }
    
    
        /**
         * 发红包
         * 群主发红包,就是把一个整数的全额分成若干等份
         *      1.获取群主的余额,是否具备发红包的能力不能发红包则返回一个null,并且提示:"余额不足!"
         *      2.修改群主的余额,此时群主的余额 = 原来的余额 - 发的红包的额度
         *      3.拆分红包
         *           随机分配红包金额
         */
        public List<BigDecimal> send(BigDecimal money,int count){
            List<BigDecimal> list= Lists.newArrayList();
            // 数据的合法性检验
            // 获取群主的余额
            BigDecimal leftMoney=super.getLeftMoney();
            // 判断是否具备发红包的能力
            if (leftMoney.compareTo(money)<0) {
                System.out.println("余额不足");
                return list;
            }
            // 修改群主余额
            super.setLeftMoney(leftMoney.subtract(money));
    
            // 发红包
            list=SplitBigDecimalUtils.splitBigDecimalFromRange(money,count,SCALE,MIN,money.subtract(MIN));
            return list;
        }
    
    
    }
    
    

    定义普通群员类

    package com.example.demo.redEnvelopes;
    
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    
    //定义普通群员类
    public class Member extends User {
    
        public Member() {
        }
    
        public Member(String name, BigDecimal leftMoney) {
            super(name, leftMoney);
        }
    
        // 收红包   receive
        public void receive(List<BigDecimal> list) {
            // 构造一个随机类对象 Random
            Random r = new Random();
            // 随机一个数是list容器中的索引  索引的取值范围 [0,list.size()]
            int index = r.nextInt(list.size());
            // 当去取一个红包,那么list容器中就要少一个红包
            BigDecimal money = list.remove(index);
            // 普通成员的余额需要增加对应的值
            super.setLeftMoney(super.getLeftMoney().add(money));
            System.out.println(getName()+"拆到了:"+getLeftMoney());
        }
    }
    
    

    红包随机金额工具类

    package com.example.demo.redEnvelopes;
    
    import org.apache.commons.compress.utils.Lists;
    
    import java.math.BigDecimal;
    import java.math.RoundingMode;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 随机分配红包
     */
    public class SplitBigDecimalUtils {
    
        /**
         * 红包总额最小金额,单位为与scale有关,例如scale为2,单位为分
         */
        private static final BigDecimal  MIN_MONEY = new BigDecimal("0.01");
        /**
         * 红包总额最大金额
         */
        private static final BigDecimal MAX_MONEY = new BigDecimal("200");
    
        /**
         * 红包金额的离散程度,值越大红包金额越分散
         */
        private static final double DISPERSE = 1;
    
        private static final BigDecimal pow = new BigDecimal(10);
    
    
        /**
         * 将一个BigDecimal 切分成指定个数指定精度指定范围的若干个数,如果范围设置不当,前面随机的数较小,可能会导致最后一个数过大超出范围
         * @param amount 总数量
         * @param count 总个数
         * @param scale 精度
         * @param min 单个红包最小值
         * @param max 单个红包最大值
         * @return
         */
        public static List<BigDecimal> splitBigDecimalFromRange(BigDecimal amount, int count, int scale, BigDecimal min, BigDecimal max) {
            BigDecimal total = BigDecimal.ZERO;
            if(amount.compareTo(MAX_MONEY)>0){
                System.out.println("红包金额超过最大限额");
                return new ArrayList<BigDecimal>();
            }
            if(amount.compareTo(MIN_MONEY)<0){
                System.out.println("红包金额不能低于最低限额");
                return new ArrayList<BigDecimal>();
            }
            System.out.println("群主发红包了,红包数量:"+count);
            List<BigDecimal> list = Lists.newArrayList();
            for (int i = 0; i < count; i++) {
                BigDecimal tem = getOneRedBag(amount.subtract(total), count - i, scale, min, max);
                total = total.add(tem);
                list.add(tem);
            }
            return list;
        }
    
        public static void main(String[] args) {
            //总量
            BigDecimal amount = new BigDecimal(20);
            System.out.println(MAX_MONEY.compareTo(amount));
            BigDecimal min = new BigDecimal(0.01);
            BigDecimal max = amount.subtract(min);
    
            List<BigDecimal> bigDecimals = splitBigDecimalFromRange(amount, 4, 2, min, max);
            System.out.println(bigDecimals);
        }
    
    
        private static BigDecimal getOneRedBag(BigDecimal amount, int count, int scale, BigDecimal min, BigDecimal max) {
            // 转成int做运算
            int amountInt = amount.setScale(scale, RoundingMode.HALF_UP).multiply(pow).intValue();
            int minInt = min.setScale(scale, RoundingMode.HALF_UP).multiply(pow).intValue();
            int maxInt = max.setScale(scale, RoundingMode.HALF_UP).multiply(pow).intValue();
            if (amountInt < minInt * count) {
                throw new RuntimeException("最小值设置过大");
            }
            if (minInt > maxInt){
                throw new RuntimeException("最大值小于最小值");
            }
            if (maxInt * count < amountInt){
                throw new RuntimeException("最大值设置过小");
            }
            //最大值不能大于总金额
            maxInt = maxInt > amountInt ? amountInt : maxInt;
            //randomBetweenMinAndMax()上面有这个方法
            return new BigDecimal(randomBetweenMinAndMax(amountInt, count, minInt, maxInt)).divide(pow, scale,
                    RoundingMode.HALF_UP);
        }
    
        /**
         * 在最小值和最大值之间随机产生一个
         *
         * @param money
         * @param count
         * @param min   : 最小量
         * @param max   : 最大量
         * @return
         */
        public static int randomBetweenMinAndMax(int money, int count, int min, int max) {
            //最后一个直接返回
            if (count == 1) {
                return money;
            }
            //最小和最大金额一样,返最小和最大值都行
            if (min == max) {
                return min;
            }
            //最小值 == 均值, 直接返回最小值
            if (min == money / count) {
                return min;
            }
            //min<=随机数bag<=max
            int bag = ((int) Math.rint(Math.random() * (max - min) + min));
    
            //剩余的均值
            int avg = (money - bag) / (count - 1);
            //比较验证剩余的还够不够分(均值>=最小值 是必须条件),不够分的话就是最大值过大
            if (avg < 1) {
                /*
                 * 重新随机一个,最大值改成本次生成的量
                 * 由于 min<=本次金额bag<=max, 所以递归时bag是不断减小的。
                 * bag在减小到min之间一定有一个值是合适的,递归结束。
                 * bag减小到和min相等时,递归也会结束,所以这里不会死递归。
                 */
                return randomBetweenMinAndMax(money, count, min, bag);
            } else {
                return bag;
            }
        }
    
    
    }
    
    

    测试类

    package com.example.demo.redEnvelopes;
    
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.List;
    
    //测试类
    public class TestRedPackage {
    
        public static void main(String[] args) {
            //构建一个群主
            //构建多个成员对象
            Lord lord = new Lord("小明", new BigDecimal(1000));
            Member m1 = new Member("小王", BigDecimal.ZERO);
            Member m2 = new Member("小刘", BigDecimal.ZERO);
            Member m3 = new Member("小孙", BigDecimal.ZERO);
            // 发红包了
           List<BigDecimal> list = lord.send(new BigDecimal("200"), 3);
            // 查看群主的余额
            lord.check();
            // 加一个判断 群主确定发出了红包
            if (list.size() == 0) {
                System.out.println("群主发红包失败了,再来");
            } else {
                // 普通成员收红包
                m1.receive(list);
                m1.check();
                m2.receive(list);
                m2.check();
                m3.receive(list);
                m3.check();
            }
    
        }
    
    }
    
    

    运行查看结果
    在这里插入图片描述

    展开全文
  • java 实现微信抢红包Dome

    千次阅读 2019-04-12 11:40:56
    java 实现微信抢红包Dome 红包的一些规则和算法,如下(随机拆分玩法): 1.每个红包金额不能小于0.01元 2.如果发送5个红包,则红包总金额不能小于0.01*5=0.05元 3.如果红包的个数大于1个,则每个红包的拆分金额不...

    java 实现微信抢红包Dome

    红包的一些规则和算法,如下(随机拆分玩法):
    1.每个红包金额不能小于0.01元
    2.如果发送5个红包,则红包总金额不能小于0.01*5=0.05元
    3.如果红包的个数大于1个,则每个红包的拆分金额不能等于红包总金额
    4.每个红包拆分的金额之和,等于红包的总金额
    5.要随机拆分,并且是没有任何顺序
    6.显示运气王

    抢红包逻辑代码

    
     public class GrapRedEnvelope { 
         public static void main(String[] args) {   
              grapRed(10,6);
    	        
         }
    		    
       
        /**
         * 拆红包
         * @param price 红包总金额
         * @param person 红包个数
         */
        public static void grapRed(int price,int person){
            List<BigDecimal> moneys = math(BigDecimal.valueOf(price), person);
            if (moneys != null) {
                BigDecimal b = new BigDecimal(0);
                int num = 1;
                for (BigDecimal bigDecimal : moneys) {
                    System.out.println("第" + num + "个人抢到:" + bigDecimal + "元    ");
                    b = b.add(bigDecimal);
                    num++;
                }
                for (int i = 0;i < moneys.size(); i++) {
                    BigDecimal bigDecimal = moneys.get(i);
                    if (bigDecimal == Collections.max(moneys)) {
                        System.out.println("运气王是第"+(i + 1)+"个人," + "金额最大值:" + Collections.max(moneys));
                    }
                }
                System.out.println("红包总额:" + b + "元 ");
            }
        }
        /**
         * 计算每人获得红包金额;最小每人0.01元
         * @param redPrice  红包总额
         * @param number 人数
         * @return
         */
        public static List<BigDecimal> math(BigDecimal redPrice, int personNumber) {
            if (redPrice.doubleValue() < personNumber * 0.01) {//发红包最少0.01*personNumber
                return null;
            }
            Random random = new Random();
            // 将红包总金额换算为单位分
            int money = redPrice.multiply(BigDecimal.valueOf(100)).intValue();
            double count = 0;// 随机数总额
            // 每人获得随机点数
            double[] arrRandom = new double[personNumber];
            // 每人获得钱数
            List<BigDecimal> arrMoney = new ArrayList<BigDecimal>(personNumber);
            // 循环人数 随机点
            for (int i = 0; i < arrRandom.length; i++) {
                int r = random.nextInt((personNumber) * 99) + 1;
                count += r;
                arrRandom[i] = r;
            }
            // 计算每人拆红包获得金额
            int c = 0;
            for (int i = 0; i < arrRandom.length; i++) {
                // 每人获得随机数相加 计算每人占百分比
                Double x = new Double(arrRandom[i] / count);
                // 每人通过百分比获得金额
                int m = (int) Math.floor(x * money);
                // 如果获得 0 金额,则设置最小值 1分钱
                if (m == 0) {
                    m = 1;
                }
                c += m;// 计算获得总额
                // 如果不是最后一个人则正常计算
                if (i < arrRandom.length - 1) {
                    arrMoney.add(new BigDecimal(m).divide(new BigDecimal(100)));
                } else {
                    // 如果是最后一个人,则把剩余的钱数给最后一个人
                    arrMoney.add(new BigDecimal(money - c + m).divide(new BigDecimal(100)));
                }
            }
            // 随机打乱每人获得金额
            Collections.shuffle(arrMoney);
            return arrMoney;
        }
    }
    

    这里还有点不足,就是传入的金额必须是整数,有望改进!
    原文地址:https://cloud.tencent.com/developer/article/1171189

    展开全文
  • Java实现微信抢红包

    2019-10-16 18:27:03
    要求:实现参与抢红包人员可以抢到随机金额,每个人必须抢到大于0的金额。 思路:1.生成(总人数-1)个范围在0到总金额的随机数,组成数组arrList; 2.通过冒泡排序按照从小到大排序; 3.将排序后的数组按照...

    要求:实现参与抢红包人员可以抢到随机金额,每个人必须抢到大于0的金额。
    思路:1.生成(总人数-1)个范围在0到总金额的随机数,组成数组arrList;

             2.通过冒泡排序按照从小到大排序;
    
             3.将排序后的数组按照arrList[i+1]-arrList[i]方式取出(总人数-1)个差值,组成一个新数组newArrList
    
                (注意:取出的第一个数据为第一个随机数,即arrList[1]-0)
    
             4.总金额减去第三步newArrList所有数据之和,得到差值作为newArrList最后一个元素;
    
             5.得到一个数组newArrList;
    
             6.接收到抽奖请求后,按顺序取newArrList中的值作为该参与者的红包金额。
    

    思路实现图:(以6个人为例)

    1.生成5个随机数升序排列

    0 5 23 46 67 79
    2.随机数后一位减前一位得到差值
    5 18 23 21 12 21
    代码实现:

    private static List getMoney(Integer totalMoney,Integer totalPersons){
    Random random = new Random();
    int[] randomNumList = new int[totalPersons-1];
    for(int i=0;i<totalPersons-1;i++){
    Integer randomNum = random.nextInt(totalMoney);
    randomNumList[i] = randomNum;
    }
    int temp = 0;
    for(int i=0;i<randomNumList.length-1;i++){
    for(int j=0;j<randomNumList.length-1-i;j++){
    if(randomNumList[j+1]<randomNumList[j]){
    temp = randomNumList[j];
    randomNumList[j] = randomNumList[j+1];
    randomNumList[j+1] = temp;
    }
    }
    }
    List moneyList = new ArrayList<>();
    int total = 0;
    for(int i=0;i<randomNumList.length;i++){
    if(i==0){
    moneyList.add(randomNumList[0]);
    total+=randomNumList[0];
    }else{
    int tempNum = randomNumList[i]-randomNumList[i-1];
    moneyList.add(tempNum);
    total+=tempNum;
    }
    }
    moneyList.add(totalMoney-total);
    return moneyList;
    }
    测试验证:
    public static void main(String[] args){
    List aa = getMoney(180,6);
    for(int a : aa){
    System.out.println(“抽取红包金额为:”+a+“元”);
    }
    }
    测试结果:
    抽取红包金额为:9元
    抽取红包金额为:24元
    抽取红包金额为:16元
    抽取红包金额为:6元
    抽取红包金额为:113元
    抽取红包金额为:12元
    [6, 9, 12, 16, 24, 113]
    Process finished with exit code 0
    ——————————————

    展开全文
  • 群主在群里发红包,其他的成员(3个)来抢红包 发红包规则: 群主使用自己的余额,暂时规定群主不允许抢, 红包平均分配成3个 100/3 不能整除 整数 余数 99/3 整除 成员抢随机红包 注意:发红包的金额和自己的余额...
  • 闲来无事,最近项目需求要写出用户登录首页来发现金红包,没有限额。...个人觉得这个算法比较模拟现实抢红包规则。废话少说。先贴代码; import java.math.BigDecimal; import java.util.ArrayList; import ja...
  • java实现抢红包功能

    千次阅读 2019-09-18 16:05:08
    java实现抢红包功能 最近项目中,实现抢红包的功能,觉得挺有意思,这边根据自己的实战经验做个总结,抢红包主要面临两个问题,一个是红包的分配算法,一个是抢红包的并发问题。 红包并发问题 并发就会考虑用锁,...
  • 主要介绍了JAVA随机数随机字母的实现(微信抢红包小练习),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java实现抢红包算法

    2020-01-20 22:39:07
    这里简单介绍一下二倍均值法。 我们为了保证每个人到的红包都均匀分布在合适的区间内,故引入二倍均值法。我们发现红包金额并不是随机分布在0~金额总数的区间内,而是...以下是java代码实现: package RedPoc...
  • Java实现抢红包

    2021-10-01 20:58:03
    import java.math.BigDecimal; import java.math.RoundingMode; import java.util.ArrayList; import java.util.List; public class RedEnvelope { public static void main(String[] args) { try { redEnvelop
  • * 随机生成抢红包的人数或手动输入人数 * @return * 人数 */ public static int IntNumberOfPeople() { boolean decide=Sys; int number; Scanner scanner =new Scanner(System.in); Random random...
  • java抢红包实现

    千次阅读 2019-06-01 00:20:02
    之前看过一篇文章介绍抢红包的,现在自己搞一哈 总体思想 说下大概思路,有一种是抢一个红包,那么下一个拿到的是总数-抢到的钱数,然后再去随机 另一种是先把钱拆分好,然后再按人头去分,这一篇主要是这种方法 ...
  • // 第一个抢红包人分钱 fhb-bj 保证每个人都有1块钱拿 int je = (1 + random.nextInt(fhb - bj)); //10-3=7 // 1-7 //10-7 =3 //3-2=1 // fhb = fhb - je; //总红包金额-抢到红包金额=剩下的红包金额 //设置...
  • 当我们在群里抢红包时真的是手速越快红包金额越大吗?答案当然是并不是,都说了是拼手气,岂能是拼手速!不过也可以有拼手速的方法抢红包二倍均值法(公平版)线段切割法(手速版)二倍均值法(公平版)这是一种很...
  • 抢红包是在并发场景下操纵和获取资源,只需要将操作和获取的过程建立线程安全机制即可; 抢红包需要多线程同时访问同一共享资源,所以将共享资源作为成员变量注入线程类中供其调用 (使用操纵内存的方式); 实现过程...
  • 今天我们谈一谈JAVA中的随机数 你好WO SHI 七七卡卡 ^ _ ^ 随机数 ——Math.random() 0.0 在Math类中存在一个random()方法,用于产生随机数字,这个方法生成在0.0<=生成数<1.0 0.1那么它默认的生成的数显然在...
  • java版微信抢红包

    2019-07-17 16:06:40
    实现拼手气红包算法,有以下几个需要注意的地方:抢红包的期望收益应与先后顺序无关 保证每个用户至少能抢到一个预设的最小金额,人民币红包设置的最小金额一般是0.01元,如果需要发其他货币类型的红包,比如区块链...
  • java案例之抢红包

    2020-02-10 23:09:11
    java案例之抢红包: 首先得知道,抢红包得分2个对象:一个是发的,多个抢的。他们都是用户,所以设计为,父类是用户类,子类是群主和群员。 一个用户得有用户名和余额所以来动手构建一个用户类代码如下: package ...
  • 实现要点 熟悉java多线程应用 ...第一种:抢红包随机生成红包(规定总金额和数量) 红包: 在抢红包的过程中剩余金额会不断减少,要保证不能两个人同时抢,需要加上悲观锁,同一时间只可以一个人抢,加s...
  • 简单实现微信抢红包的功能(Java)

    千次阅读 2020-04-04 23:36:19
    简单实现微信抢红包的功能(Java) package 数据很美; import java.util.Random; import java.util.Scanner; public class 简单模拟微信抢红包小程序 { public static void main(String[] args) { Scanner sc=new ...
  • java多线程实现抢红包

    万次阅读 2017-10-29 21:54:04
    首先抢红包,人、红包抽象为两个对象,人(获取到红包)红包(总额,数量,提供生成随机金额方法) 其中,生成随机红包有两种方案,第一种:获取的时候生成,第二种:先生成好所有的红包 对于两种方案都涉及到数据...
  • nextInt() 返回随机生成int值 nextLong() 返回随机long值 nextDouble() 返回随机Double值 nextFloat() 返回随机Float值 nextBoolean() 返回随机Boolean值 最常用的是nextInt(int n)方法,参数是一个int值,取值范围...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,211
精华内容 484
关键字:

java实现随机抢红包

java 订阅