java实现幸运抽奖（java抽奖程序,可设置不同奖品获得概率）

2026-01-12 22:45:02 ：0

这篇文章给大家聊聊关于java实现幸运抽奖，以及java抽奖程序,可设置不同奖品获得概率对应的知识点，希望对各位有所帮助，不要忘了收藏本站哦。

本文目录

java抽奖程序,可设置不同奖品获得概率
JAVA抽奖问题
用swing编写一个java抽奖的程序，至少有5个按钮，显得高大上一点
如何用java技术实现幸运抽奖活动系统
商场推出幸运抽奖活动的java初级代码编写
Java中一道题，for循环做一个幸运抽奖系统，如何做到先注册才能登陆，登陆后才能抽奖，此三步骤求解!
java集五福活动概率技术如何实现

java抽奖程序,可设置不同奖品获得概率

import java.awt.EventQueue;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.border.EmptyBorder;
public class LuckySelect extends JFrame {
private JPanel contentPane;
private JTextField textFieldA;
private JTextField textFieldB;
private JTextField textFieldC;
private TextField textField;
private JTextField textFieldResult;
private JTextArea textArea;
/**
* Launch the application.
*/
public static void main(String args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
LuckySelect frame = new LuckySelect();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
*/
public LuckySelect() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 450, 251);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
contentPane.setLayout(null);
setContentPane(contentPane);
JLabel lblA = new JLabel("A");
lblA.setBounds(10, 128, 54, 15);
contentPane.add(lblA);
JLabel lblB = new JLabel("B");
lblB.setBounds(124, 128, 54, 15);
contentPane.add(lblB);
JLabel lblC = new JLabel("C");
lblC.setBounds(254, 128, 54, 15);
contentPane.add(lblC);
textFieldA = new JTextField();
textFieldA.setBounds(30, 125, 66, 21);
contentPane.add(textFieldA);
textFieldA.setColumns(10);
textFieldB = new JTextField();
textFieldB.setColumns(10);
textFieldB.setBounds(149, 125, 66, 21);
contentPane.add(textFieldB);
textFieldC = new JTextField();
textFieldC.setColumns(10);
textFieldC.setBounds(264, 125, 66, 21);
contentPane.add(textFieldC);
textField = new TextField();
textField.setBounds(98, 167, 157, 21);
contentPane.add(textField);
textField.setColumns(10);
textFieldResult = new JTextField();
textFieldResult.setBounds(280, 167, 66, 21);
contentPane.add(textFieldResult);
textFieldResult.setColumns(10);
textFieldA.setText("10");
textFieldB.setText("10");
textFieldC.setText("10");
JButton button = new JButton("\u62BD\u5956");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
select();
}
});
button.setBounds(0, 166, 93, 23);
contentPane.add(button);
textArea = new JTextArea();
textArea.setBounds(30, 31, 306, 83);
contentPane.add(textArea);
}
protected void select() {
// TODO Auto-generated method stub
int aNum = Integer.decode(textFieldA.getText());
int bNum = Integer.decode(textFieldB.getText());
int cNum = Integer.decode(textFieldB.getText());
Random r = new Random();
int random = r.nextInt(aNum + bNum + cNum);
if(random 《= aNum){
textFieldA.setText(Integer.toString(Integer.decode(textFieldA.getText()) - 1));
textArea.append(Integer.toString(random) + "抽中了A\n");
}else if(random 《= aNum + bNum){
textFieldB.setText(Integer.toString(Integer.decode(textFieldB.getText()) - 1));
textArea.append(Integer.toString(random) + "抽中了B\n");
}else if(random 《= aNum + bNum + cNum){
textFieldC.setText(Integer.toString(Integer.decode(textFieldC.getText()) - 1));
textArea.append(Integer.toString(random) + "抽中了C\n");
}
}
}

JAVA抽奖问题

import java.util.Scanner;public class TextRandom {
public static Scanner input=new Scanner(System.in);
public static int count=0;//记录用户猜对的次数
public static int xitong =(int)Math.round(Math.random()*10);//系统产生的随机数0~10之间
public static int w;//将系统随即产生的数字放在数组W中
public static int guess;
public static void main(Stringargs)
{
guess();
}
public static void guess()
{ //开始抽奖
for(int j=0;j《w.length;j++){
System.out.println("开始抽奖，请用户输入0~10之间的数字，请输入第"+(j+1)+"个数字");
guess =input.nextInt();
if(j《2){
System.out.println("正在摇奖，需要中途放弃么？(y/n)");
String shuru =input.next();
if(shuru.equals(’y’)) break;

}
}
//系通开出的奖
System.out.println("系统产生三个数字是：");
for(int i=0;i《3;i++)
{
System.out.print((int)Math.round(Math.random()*10));
w=(int)Math.round(Math.random()*10);
}
//兑奖过程
for(int i=0;i《3;i++)
{
if(guess)
{
count++;//记录出用户抽中奖的次数
}
}
if(count==3)
{
System.out.println("恭喜你，你中奖了 ");
}
else
{
System.out.println("很遗憾，您没有中奖，欢迎下次再来！");
}
}
}
//我已尽力了

用swing编写一个java抽奖的程序，至少有5个按钮，显得高大上一点

‍

import java.awt.Color;//界面不是很高大上档次，但是能满足你的基本需求，希望对你有用
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
public class 抽奖游戏 extends JFrame {
static 抽奖游戏 frame;
public 抽奖游戏() {
  setLayout(new GridLayout(3, 3, 3, 3));
  Border border = new LineBorder(Color.BLUE, 4);
  JButton l1 = new JButton();
  JButton l2 = new JButton();
  JButton l3 = new JButton();
  JButton l4 = new JButton();
  JButton l5 = new JButton();
  JButton l6 = new JButton();
  JButton l7 = new JButton("祝你好运");
  JButton l8 = new JButton("中奖规则");
  JButton l9 = new JButton("再次抽奖");
  l1.setBorder(border);
  l2.setBorder(border);
  l3.setBorder(border);
  l4.setBorder(border);
  l5.setBorder(border);
  l6.setBorder(border);
  l7.setBorder(border);
  l8.setBorder(border);
  l9.setBorder(border);
  String num2 = { "1", "2", "3", "4", "5", "6" };
  l8.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    JOptionPane.showMessageDialog(null, "游戏规则:\n" + "特等奖:\n"
      + "第一行或者第二行出现的数字全部相同\n"
      + "第一第二行出现升序的1,2,3,4,5,6或者降序的6,5,4,3,2,1\n" + "一等奖\n"
      + "1:第一行或第二行的数字降序排列或者升序排列\n"
      + "2:第一行或者第二行相邻的按钮出现一样的数字\n");
   }
  });
  l9.addActionListener(new ActionListener() {
   @Override
   public void actionPerformed(ActionEvent e) {
    // TODO Auto-generated method stub
    l1.setText("*");
    l2.setText("*");
    l3.setText("*");
    l4.setText("*");
    l5.setText("*");
    l6.setText("*");
    l7.setBackground(Color.lightGray);
    l7.setText("离中奖不远了！");
   }
  });
  l6.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    int j1 = (int) (Math.random() * 10) % 6;
    l1.setText(num2);
    int j2 = (int) (Math.random() * 10) % 6;
    l2.setText(num2);
    int j3 = (int) (Math.random() * 10) % 6;
    l3.setText(num2);
    int j4 = (int) (Math.random() * 10) % 6;
    l4.setText(num2);
    int j5 = (int) (Math.random() * 10) % 6;
    l5.setText(num2);
    int j6 = (int) (Math.random() * 10) % 6;
    l6.setText(num2);
    if (j1 == j2 && j2 == j3 || j4 == j5 && j5 == j6 || j1 == 1
      && j2 == 2 && j3 == 3 && j4 == 4 && j5 == 5 && j6 == 6
      || j1 == 6 && j2 == 5 && j3 == 4 && j4 == 3 && j5 == 2
      && j6 == 1) {
     l7.setBackground(Color.red);
     l7.setText("特等奖");
    } else if (j1 》 j2 && j2 》 j3 || j3 》 j2 && j2 》 j1 || j4 》 j5
      && j5 》 j6 || j6 》 j5 && j5 》 j4 || j1 == j2
      && j5 == j4 || j1 == j2 && j5 == j6 || j3 == j2
      && j4 == j5 || j5 == j6 && j2 == j3) {
     l7.setBackground(Color.YELLOW);
     l7.setText("一等奖");
    } else {
     l7.setBackground(Color.lightGray);
     l7.setText("未中奖，加油！");
    }
   }
  });
  l5.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    int j1 = (int) (Math.random() * 10) % 6;
    l1.setText(num2);
    int j2 = (int) (Math.random() * 10) % 6;
    l2.setText(num2);
    int j3 = (int) (Math.random() * 10) % 6;
    l3.setText(num2);
    int j4 = (int) (Math.random() * 10) % 6;
    l4.setText(num2);
    int j5 = (int) (Math.random() * 10) % 6;
    l5.setText(num2);
    int j6 = (int) (Math.random() * 10) % 6;
    l6.setText(num2);
    if (j1 == j2 && j2 == j3 || j4 == j5 && j5 == j6 || j1 == 1
      && j2 == 2 && j3 == 3 && j4 == 4 && j5 == 5 && j6 == 6
      || j1 == 6 && j2 == 5 && j3 == 4 && j4 == 3 && j5 == 2
      && j6 == 1) {
     l7.setBackground(Color.red);
     l7.setText("特等奖");
    } else if (j1 》 j2 && j2 》 j3 || j3 》 j2 && j2 》 j1 || j4 》 j5
      && j5 》 j6 || j6 》 j5 && j5 》 j4 || j1 == j2
      && j5 == j4 || j1 == j2 && j5 == j6 || j3 == j2
      && j4 == j5 || j5 == j6 && j2 == j3) {
     l7.setBackground(Color.YELLOW);
     l7.setText("一等奖");
    } else {
     l7.setBackground(Color.lightGray);
     l7.setText("未中奖，加油！");
    }
   }
  });
  l4.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    int j1 = (int) (Math.random() * 10) % 6;
    l1.setText(num2);
    int j2 = (int) (Math.random() * 10) % 6;
    l2.setText(num2);
    int j3 = (int) (Math.random() * 10) % 6;
    l3.setText(num2);
    int j4 = (int) (Math.random() * 10) % 6;
    l4.setText(num2);
    int j5 = (int) (Math.random() * 10) % 6;
    l5.setText(num2);
    int j6 = (int) (Math.random() * 10) % 6;
    l6.setText(num2);
    if (j1 == j2 && j2 == j3 || j4 == j5 && j5 == j6 || j1 == 1
      && j2 == 2 && j3 == 3 && j4 == 4 && j5 == 5 && j6 == 6
      || j1 == 6 && j2 == 5 && j3 == 4 && j4 == 3 && j5 == 2
      && j6 == 1) {
     l7.setBackground(Color.red);
     l7.setText("特等奖");
    } else if (j1 》 j2 && j2 》 j3 || j3 》 j2 && j2 》 j1 || j4 》 j5
      && j5 》 j6 || j6 》 j5 && j5 》 j4 || j1 == j2
      && j5 == j4 || j1 == j2 && j5 == j6 || j3 == j2
      && j4 == j5 || j5 == j6 && j2 == j3) {
     l7.setBackground(Color.YELLOW);
     l7.setText("一等奖");
    } else {
     l7.setBackground(Color.lightGray);
     l7.setText("未中奖，加油！");
    }
   }
  });
  l3.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    int j1 = (int) (Math.random() * 10) % 6;
    l1.setText(num2);
    int j2 = (int) (Math.random() * 10) % 6;
    l2.setText(num2);
    int j3 = (int) (Math.random() * 10) % 6;
    l3.setText(num2);
    int j4 = (int) (Math.random() * 10) % 6;
    l4.setText(num2);
    int j5 = (int) (Math.random() * 10) % 6;
    l5.setText(num2);
    int j6 = (int) (Math.random() * 10) % 6;
    l6.setText(num2);
    if (j1 == j2 && j2 == j3 || j4 == j5 && j5 == j6 || j1 == 1
      && j2 == 2 && j3 == 3 && j4 == 4 && j5 == 5 && j6 == 6
      || j1 == 6 && j2 == 5 && j3 == 4 && j4 == 3 && j5 == 2
      && j6 == 1) {
     l7.setBackground(Color.red);
     l7.setText("特等奖");
    } else if (j1 》 j2 && j2 》 j3 || j3 》 j2 && j2 》 j1 || j4 》 j5
      && j5 》 j6 || j6 》 j5 && j5 》 j4 || j1 == j2
      && j5 == j4 || j1 == j2 && j5 == j6 || j3 == j2
      && j4 == j5 || j5 == j6 && j2 == j3) {
     l7.setBackground(Color.YELLOW);
     l7.setText("一等奖");
    } else {
     l7.setBackground(Color.lightGray);
     l7.setText("未中奖，加油！");
    }
   }
  });
  l2.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    int j1 = (int) (Math.random() * 10) % 6;
    l1.setText(num2);
    int j2 = (int) (Math.random() * 10) % 6;
    l2.setText(num2);
    int j3 = (int) (Math.random() * 10) % 6;
    l3.setText(num2);
    int j4 = (int) (Math.random() * 10) % 6;
    l4.setText(num2);
    int j5 = (int) (Math.random() * 10) % 6;
    l5.setText(num2);
    int j6 = (int) (Math.random() * 10) % 6;
    l6.setText(num2);
    if (j1 == j2 && j2 == j3 || j4 == j5 && j5 == j6 || j1 == 1
      && j2 == 2 && j3 == 3 && j4 == 4 && j5 == 5 && j6 == 6
      || j1 == 6 && j2 == 5 && j3 == 4 && j4 == 3 && j5 == 2
      && j6 == 1) {
     l7.setBackground(Color.red);
     l7.setText("特等奖");
    } else if (j1 》 j2 && j2 》 j3 || j3 》 j2 && j2 》 j1 || j4 》 j5
      && j5 》 j6 || j6 》 j5 && j5 》 j4 || j1 == j2
      && j5 == j4 || j1 == j2 && j5 == j6 || j3 == j2
      && j4 == j5 || j5 == j6 && j2 == j3) {
     l7.setBackground(Color.YELLOW);
     l7.setText("一等奖");
    } else {
     l7.setBackground(Color.lightGray);
     l7.setText("未中奖，加油！");
    }
   }
  });
  l1.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    // TODO Auto-generated method stub
    int j1 = (int) (Math.random() * 10) % 6;
    l1.setText(num2);
    int j2 = (int) (Math.random() * 10) % 6;
    l2.setText(num2);
    int j3 = (int) (Math.random() * 10) % 6;
    l3.setText(num2);
    int j4 = (int) (Math.random() * 10) % 6;
    l4.setText(num2);
    int j5 = (int) (Math.random() * 10) % 6;
    l5.setText(num2);
    int j6 = (int) (Math.random() * 10) % 6;
    l6.setText(num2);
    if (j1 == j2 && j2 == j3 || j4 == j5 && j5 == j6 || j1 == 1
      && j2 == 2 && j3 == 3 && j4 == 4 && j5 == 5 && j6 == 6
      || j1 == 6 && j2 == 5 && j3 == 4 && j4 == 3 && j5 == 2
      && j6 == 1) {
     l7.setBackground(Color.red);
     l7.setText("特等奖");
    } else if (j1 》 j2 && j2 》 j3 || j3 》 j2 && j2 》 j1 || j4 》 j5
      && j5 》 j6 || j6 》 j5 && j5 》 j4 || j1 == j2
      && j5 == j4 || j1 == j2 && j5 == j6 || j3 == j2
      && j4 == j5 || j5 == j6 && j2 == j3) {
     l7.setBackground(Color.YELLOW);
     l7.setText("一等奖");
    } else {
     l7.setBackground(Color.lightGray);
     l7.setText("未中奖，加油！");
    }
   }
  });
  Font font = new Font("", Font.BOLD, 20);
  l1.setFont(font);
  l2.setFont(font);
  l3.setFont(font);
  l4.setFont(font);
  l5.setFont(font);
  l6.setFont(font);
  l7.setFont(font);
  l8.setFont(font);
  l9.setFont(font);
  add(l1);
  add(l2);
  add(l3);
  add(l4);
  add(l5);
  add(l6);
  add(l7);
  add(l8);
  add(l9);
}
public static void main(String args) {
  // TODO Auto-generated method stub
  frame = new 抽奖游戏();
  frame.setTitle("抽奖大战");
  frame.setSize(500, 500);
  frame.setLocationRelativeTo(null);
  frame.setVisible(true);
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

如何用java技术实现幸运抽奖活动系统

import java.util.Scanner;
public class LuckyNumber {
/**
* 幸运抽奖
*/
public static
void main(String args) {
String answer
= "y"; // 标识是否继续
String
userName = ""; // 用户名
String
password = ""; // 密码
int cardNumber
= 0; // 卡号
boolean
isRegister = false; // 标识是否注册
boolean
isLogin = false; // 标识是否登录
int max =
9999;
int min =
1000;
Scanner input
= new Scanner(System.in);
do {
System.out.println("*****欢迎进入奖客富翁系统*****");
System.out.println("\t1.注册");
System.out.println("\t2.登录");
System.out.println("\t3.抽奖");
System.out.println("***************************");
System.out.print("请选择菜单：");
int choice =
input.nextInt();
switch
(choice) {
case 1:
System.out.println("[奖客富翁系统
》注册]");
System.out.println("请填写个人注册信息：");
System.out.print("用户名：");
userName =
input.next();
System.out.print("密码：");
password =
input.next();
//
获取4位随机数作为卡号
cardNumber =
(int)(Math.random()*(max-min))+min;
System.out.println("\n注册成功，请记好您的会员卡号");
System.out.println("用户名\t密码\t会员卡号");
System.out.println(userName
+ "\t" + password + "\t" + cardNumber);
isRegister =
true; // 注册成功，标志位设置为true
break;
case 2:
System.out.println("[奖客富翁系统
》登录]");
if
(isRegister) { // 判断是否注册
//
3次输入机会
for (int i
= 1; i 《= 3; i++) {
System.out.print("请输入用户名：");
String
inputName = input.next();
System.out.print("请输入密码：");
String
inputPassword = input.next();
if
(userName.equals(inputName) && password.equals(inputPassword)) {
System.out.println("\n欢迎您："
+ userName);
isLogin =
true; // 登录成功，标志位设置为true
break;
} else if
(i 《 3) {
System.out.println("用户名或密码错误，还有"
+ (3 - i) + "次机会！");
} else
{
System.out.println("您3次均输入错误！");
}
}
} else
{
System.out.println("请先注册，再登录！");
}
break;
case 3:
System.out.println("[奖客富翁系统
》抽奖]");
if
(!isLogin) { // 判断是否登录
System.out.println("请先登录，再抽奖！");
} else
{
//生成5个4位随机数字，并保存在数组中
int
luckynums = new int;
for(int i
= 0; i 《 luckynums.length; i++){
luckynums =
(int)(Math.random()*(max-min))+min;
}
System.out.print("请输入您的卡号：");
int
yourcard = input.nextInt();
int
i;
System.out.print("\n本日的幸运数字为：");
for (i = 0;
i 《 luckynums.length; i++) {
System.out.print(luckynums
+ " ");\
}
for (i = 0;
i 《 luckynums.length; i++) {
if
(luckynums == yourcard) {
System.out.println("\n恭喜！您是本日的幸运会员！");
break;
}
}
if (i ==
luckynums.length) {
System.out.println("\n抱歉！您不是本日的幸运会员！");
}
}
break;
default:
System.out.println("");
break;
}
System.out.print("继续吗？（y/n）:");
answer =
input.next();
System.out.println("");
} while
("y".equals(answer));
if
("n".equals(answer)) {
System.out.println("系统退出，谢谢使用！");
}
}
}

商场推出幸运抽奖活动的java初级代码编写

public class Lucky {
public static void main(String args){
System.out.println("请输入您的4位会员卡号:");
Scanner sc = new Scanner(System.in);
int number = sc.nextInt(); //接收用户从控制台输入的会员卡号，并保存在会员卡号变量中
int a = number/1000; //千位
int b = number%1000/100; //百位
int c = number%100/10; //十位
int d = number%10; //个位
if((a+b+c+d)》20){
System.out.println("恭喜中奖!您是幸运客户");
}else{
System.out.println("谢谢参与!");
}
}
}
最基础的没有异常判断无限循环输入什么东西

Java中一道题，for循环做一个幸运抽奖系统，如何做到先注册才能登陆，登陆后才能抽奖，此三步骤求解!

1、用户注册。
建议使用map保存用户数据。key为账号，value为密码。启动的时候new一个hashmap。然后注册的时候往map里面put值。
当然如果你要用xml、properties甚至是数据库保存用户数据也行。
2、用户登陆。
直接判断map中有没有账号。然后匹配密码是否正确。
3、抽奖。
不知道你要怎么抽，每次抽几个。然后肯定要先注册几个账号进去。不然没有数据。
把map的keyset取出来，转换成一个数组，然后随机数组长度以内的整数，这个可能需要控制好是不是重复获取的问题。根据随机的数去数组中取账号。

java集五福活动概率技术如何实现

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* 抽奖工具类,概率和可以不等于1
* 概率为百分数去掉百分号的部分，如10%，则为10
* 抽奖操作如下：
* 1.输入抽奖概率集合，【抽奖概率集合为{10.0, 20.0, 30.0}】
* 2.生成连续集合，【生成的连续集合为{(0.0, 10.0],(10.0, 30.0],(30.0, 60.0]}】
* 3.生成随机数，【生成方法为 random.nextDouble() * maxElement】
* 4.判断随机数在哪个区间内，返回该区间的index【生成了随机数12.001，则它属于(10.0, 30.0]，返回 index = 1】
*
*/
public class LotteryUtil {
/**
* 定义一个连续集合
* 集合中元素x满足:(minElement,maxElement]
* 数学表达式为：minElement 《 x 《= maxElement
*
*/
public class ContinuousList {
private double minElement;
private double maxElement;
public ContinuousList(double minElement, double maxElement){
if(minElement 》 maxElement){
throw new IllegalArgumentException("区间不合理，minElement不能大于maxElement！");
}
this.minElement = minElement;
this.maxElement = maxElement;
}
/**
* 判断当前集合是否包含特定元素
* @param element
* @return
*/
public boolean isContainKey(double element){
boolean flag = false;
if(element 》 minElement && element 《= maxElement){
flag = true;
}
return flag;
}
}
private List《ContinuousList》 lotteryList; //概率连续集合
private double maxElement; //这里只需要最大值，最小值默认为0.0
/**
* 构造抽奖集合
* @param list 为奖品的概率
*/
public LotteryUtil(List《Double》 list){
lotteryList = new ArrayList《ContinuousList》();
if(list.size() == 0){
throw new IllegalArgumentException("抽奖集合不能为空！");
}
double minElement = 0d;
ContinuousList continuousList = null;
for(Double d : list){
minElement = maxElement;
maxElement = maxElement + d;
continuousList = new ContinuousList(minElement, maxElement);
lotteryList.add(continuousList);
}
}
/**
* 进行抽奖操作
* 返回：奖品的概率list集合中的下标
*/
public int randomColunmIndex(){
int index = -1;
Random r = new Random();
double d = r.nextDouble() * maxElement; //生成0-1间的随机数
if(d == 0d){
d = r.nextDouble() * maxElement; //防止生成0.0
}
int size = lotteryList.size();
for(int i = 0; i 《 size; i++){
ContinuousList cl = lotteryList.get(i);
if(cl.isContainKey(d)){
index = i;
break;
}
}
if(index == -1){
throw new IllegalArgumentException("概率集合设置不合理！");
}
return index;
}
public double getMaxElement() {
return maxElement;
}
public List《ContinuousList》 getLotteryList() {
return lotteryList;
}
public void setLotteryList(List《ContinuousList》 lotteryList) {
this.lotteryList = lotteryList;
}
}

该工具类的基本思想是，将抽奖概率分布到数轴上，如现有三个抽奖概率10、20、30，将三者依次添加到概率集合中，则构造的数轴为：0~10范围内表示概率10，10~30范围内表示概率为20，30~60范围内表示概率为30，数轴上的长度对应着相应的概率。由这种处理方式可知，概率总和并不需要等于1。该工具类的成功与否在于Random.nextDouble()能否等概率地生成0~1之间的任意一个数。

对该抽奖工具进行测试，测试类如下：

view plain copy

package com.lottery;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
class Result{
private int index;
private int sumTime;
private int time;
private double probability;
private double realProbability;
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public int getSumTime() {
return sumTime;
}
public void setSumTime(int sumTime) {
this.sumTime = sumTime;
}
public double getProbability() {
return probability;
}
public double getRealProbability() {
return realProbability;
}
public void setRealProbability(double realProbability) {
this.realProbability = realProbability;
}
public Result(){
}
public Result(int index, int sumTime, int time, double realProbability) {
this.setIndex(index);
this.setTime(time);
this.setSumTime(sumTime);
this.setRealProbability(realProbability);
}
public String toString(){
return "索引值：" + index + "，抽奖总数：" + sumTime + "，抽中次数：" + time + "，概率："
+ realProbability + "，实际概率：" + (double)time/sumTime;
}
}
public class TestLottery {
static final int TIME = 100000;
public static void iteratorMap(Map《Integer, Integer》 map, List《Double》 list){
for(Entry《Integer, Integer》 entry : map.entrySet()){
int index = entry.getKey();
int time = entry.getValue();
Result result = new Result(index, TIME, time, list.get(index));
System.out.println(result);
}
}
public static void main(String args) {
//构造概率集合
List《Double》 list = new ArrayList《Double》();
list.add(20d);
list.add(80d);
list.add(50d);
list.add(30d);
LotteryUtil ll = new LotteryUtil(list);
double sumProbability = ll.getMaxElement();
Map《Integer, Integer》 map = new HashMap《Integer, Integer》();
for(int i = 0; i 《 TIME; i++){
int index = ll.randomColunmIndex();
if(map.containsKey(index)){
map.put(index, map.get(index) + 1);
}else{
map.put(index, 1);
}
}
for(int i = 0; i 《 list.size(); i++){
double probability = list.get(i) / sumProbability;
list.set(i, probability);
}
iteratorMap(map, list);
}
}

运行结果：

由结果可知，抽奖100000时，得到的实际概率基本与正式概率相当。

以下说明此类调用方式：

view plain copy

public LotteryUtil(List《Double》 list)
说明：构造方法，传入参数为一个概率集合

view plain copy

public int randomColunmIndex()
功能：进行抽奖操作，返回List集合的索引下标，此下标对应的概率的奖品即为抽中的奖品

以上就是我们为大家找到的有关“java实现幸运抽奖（java抽奖程序,可设置不同奖品获得概率）”的所有内容了，希望可以帮助到你。如果对我们网站的其他内容感兴趣请持续关注本站。

java实现幸运抽奖（java抽奖程序,可设置不同奖品获得概率）

本文编辑：admin

： java实现幸运抽奖

上一篇：下面属于类选择器的是（以下什么是合法的类选择器名称）

下一篇：mathematica10下载（mathematica免费下载地址）

更多文章：

dul是什么意思（nsk轴承dul和sul的区别）

其实dul是什么意思的问题并不复杂，但是又很多的朋友都不太了解nsk轴承dul和sul的区别，因此呢，今天小编就来为大家分享dul是什么意思的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！本文目录nsk轴承dul和sul

2026年5月15日 15:30

中国移动个人主页（中国移动我的页面在哪打开）

本篇文章给大家谈谈中国移动个人主页，以及中国移动我的页面在哪打开对应的知识点，文章可能有点长，但是希望大家可以阅读完，增长自己的知识，最重要的是希望对各位有所帮助，可以解决了您的问题，不要忘了收藏本站喔。本文目录中国移动我的页面在哪打开中国

2026年1月3日 16:15

grocery联想记忆（grocery怎么拆分记忆）

本篇文章给大家谈谈grocery联想记忆，以及grocery怎么拆分记忆对应的知识点，文章可能有点长，但是希望大家可以阅读完，增长自己的知识，最重要的是希望对各位有所帮助，可以解决了您的问题，不要忘了收藏本站喔。本文目录grocery怎么拆

2025年8月26日 06:00

gridview排序功能属性（怎么把datagridview中的自动排序功能禁用）

大家好，如果您还对gridview排序功能属性不太了解，没有关系，今天就由本站为大家分享gridview排序功能属性的知识，包括怎么把datagridview中的自动排序功能禁用的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始

2025年6月15日 08:45

易语言主程序和dll通讯（C+的dll如何用易语言正确调用）

今天给各位分享C+的dll如何用易语言正确调用的知识，其中也会对C+的dll如何用易语言正确调用进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！本文目录C+的dll如何用易语言正确调用易语言如何调用dll文件易语言如何

2026年4月8日 14:30

strut是什么车（这是什么品牌的车标）

大家好，strut是什么车相信很多的网友都不是很明白，包括这是什么品牌的车标也是一样，不过没有关系，接下来就来为大家分享关于strut是什么车和这是什么品牌的车标的一些知识点，大家可以关注收藏，免得下次来找不到哦，下面我们开始吧！本文目录这

2026年8月3日 11:15

前端如何判断（如何判断一个前端人员的逻辑性）

今天给各位分享如何判断一个前端人员的逻辑性的知识，其中也会对如何判断一个前端人员的逻辑性进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！本文目录如何判断一个前端人员的逻辑性前端如何判断当天是否签到怎样快速判断一个前端工

2026年9月24日 21:30

怎么制作网站ping工具（ping是什么如何ping一个站点）

大家好，如果您还对怎么制作网站ping工具不太了解，没有关系，今天就由本站为大家分享怎么制作网站ping工具的知识，包括ping是什么如何ping一个站点的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始吧！本文目录ping是

2026年4月7日 09:15

前端样式网站（前端开发应该知道的几个CSS网页表单布局技巧）

今天给各位分享前端开发应该知道的几个CSS网页表单布局技巧的知识，其中也会对前端开发应该知道的几个CSS网页表单布局技巧进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！本文目录前端开发应该知道的几个CSS网页表单布局技

2026年2月10日 21:15

网址的url（网站URL:是什么）

大家好，关于网址的url很多朋友都还不太明白，不过没关系，因为今天小编就来为大家分享关于网站URL:是什么的知识点，相信应该可以解决大家的一些困惑和问题，如果碰巧可以解决您的问题，还望关注下本站哦，希望对各位有所帮助！本文目录网站URL:是

2026年4月24日 04:30

flash模板照片幻灯片放映按钮代码解释？如何使用C#操作幻灯片

大家好，如果您还对幻灯片代码不太了解，没有关系，今天就由本站为大家分享幻灯片代码的知识，包括flash模板照片幻灯片放映按钮代码解释的问题都会给大家分析到，还望可以解决大家的问题，下面我们就开始吧！本文目录flash模板照片幻灯片放映按钮代

2025年7月24日 18:45

alarm和clock的区别（clock是什么意思英语）

其实alarm和clock的区别的问题并不复杂，但是又很多的朋友都不太了解clock是什么意思英语，因此呢，今天小编就来为大家分享alarm和clock的区别的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！本文目录clo

2025年10月20日 22:00

delphi bit定义（delphi中如何定义TBitmap类型的变量）

各位老铁们，大家好，今天由我来为大家分享delphi bit定义，以及delphi中如何定义TBitmap类型的变量的相关问题知识，希望对大家有所帮助。如果可以帮助到大家，还望关注收藏下本站，您的支持是我们最大的动力，谢谢大家了哈，下面我们

2025年11月14日 19:00

bankstatement中文（bank statement是什么意思）

“bankstatement中文”相关信息最新大全有哪些，这是大家都非常关心的，接下来就一起看看bankstatement中文（bank statement是什么意思）！本文目录bank statement是什么意思签证所需要的bank s

2026年4月5日 01:45

linux如何编程（linux编程开发如何实现对智能手机的开发）

“linux如何编程”相关信息最新大全有哪些，这是大家都非常关心的，接下来就一起看看linux如何编程（linux编程开发如何实现对智能手机的开发）！本文目录linux编程开发如何实现对智能手机的开发如何通过mac os系统学习linux系

2025年12月23日 13:00

compareto方法实现（java中compareto实现学生成绩排列）

大家好,今天小编来为大家解答以下的问题，关于compareto方法实现，java中compareto实现学生成绩排列这个很多人还不知道，现在让我们一起来看看吧！本文目录java中compareto实现学生成绩排列代码中是怎么调用compar

2026年4月28日 01:00

filterout（filter怎么记忆）

其实filterout的问题并不复杂，但是又很多的朋友都不太了解filter怎么记忆，因此呢，今天小编就来为大家分享filterout的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！本文目录filter怎么记忆filte

2026年3月30日 06:00

lodop插件怎么下载（clodop下载失败怎么回事）

各位老铁们，大家好，今天由我来为大家分享lodop插件怎么下载，以及clodop下载失败怎么回事的相关问题知识，希望对大家有所帮助。如果可以帮助到大家，还望关注收藏下本站，您的支持是我们最大的动力，谢谢大家了哈，下面我们开始吧！本文目录cl

2026年3月11日 18:00

pgc中国参赛队伍（pnc全明星赛赛程）

其实pgc中国参赛队伍的问题并不复杂，但是又很多的朋友都不太了解pnc全明星赛赛程，因此呢，今天小编就来为大家分享pgc中国参赛队伍的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！本文目录pnc全明星赛赛程PGC第三周周

2026年2月17日 03:45

win8如何重装系统（怎么重新安装win8系统|win8如何重新安装系统）

大家好，win8如何重装系统相信很多的网友都不是很明白，包括怎么重新安装win8系统|win8如何重新安装系统也是一样，不过没有关系，接下来就来为大家分享关于win8如何重装系统和怎么重新安装win8系统|win8如何重新安装系统的一些知识

2026年5月29日 06:45

java实现幸运抽奖（java抽奖程序,可设置不同奖品获得概率）

本文目录

java抽奖程序,可设置不同奖品获得概率

JAVA抽奖问题

用swing编写一个java抽奖的程序，至少有5个按钮，显得高大上一点

如何用java技术实现幸运抽奖活动系统

商场推出幸运抽奖活动的java初级代码编写

Java中一道题，for循环做一个幸运抽奖系统，如何做到先注册才能登陆，登陆后才能抽奖，此三步骤 求解!

java集五福活动概率技术如何实现

更多文章：

Java中一道题，for循环做一个幸运抽奖系统，如何做到先注册才能登陆，登陆后才能抽奖，此三步骤求解!