java计算概率

① java程序：编写生成100个1-6之间的随机数，统计1—6每个出现的概率，菜鸟看不懂程序

1.用内置方法Math.random()产生一个随机数介于0～1。
2.强制转化为int类型，根据int类型的特点，这个数是0～5之间的整数。
3.得到的数加1，这样这个数就是介于1～6的整数，并且是随机的。
4.将介于1～6之间的这个整数赋值给randomNum
5.（重点）probability是个数组，这个程序的算法就是：利用probability这个数组记录随机数出现的次数，probability[0]记录随机数1出现的次数，就是当出现的随机数为1时，数组的probability[randomNum-1]项加1（randomNum-1是为了表现算法，实际的程序中是不需要先加1再减1的）。同理：其它的随意数也做这样的处理。这样，probability这个数组中[0]项保存的是1的出现次数，[1]项保存的是2出现的次数…………
6.输出随机数的值（后面加个空格“\t”）
7.循环到步骤第1.个步骤.

② 初学java，突然想算一下买20年双色球中一等奖概率，用java编译时没出错，运行时出错了。问一下哪错了。

classSsq{
	publicstaticvoidmain(String[]args){
		//Gailvaa=newZonggailv();
		System.out.println(Zonggailv.g());
	}
}

java里面一般用println输出。

③ Java编程生成100个1~6之间的随机数,统计1~6每个数出现的概率;

• 首先:关于随机数的生成方法
  

java里生成随机数主要有2个方法比较常用.

1.Random类. 在java.util.包里, 有多种方法可以随机产生int, long, double,boolean等类型

2.Math 类,在java.lang.包里, 可以生成一个[0~1)之间的随机浮点数

*备注* :a. )使用Random需要导包,但是使用Math无需导包.

b. )Math底层还是调用了Random类的nextDouble()方法

• 其次:关于随机数的代码

例如生成[1,6]之间的随机数

1 .Random的方法,生成的随机数

Randomr=newRandom();	
intnum1=r.nextInt(6)+1;//r.next(6)生成的是0~5之间的数字,需要+1,才是[1~6]之间的数字

2. Math的方法,进行随机数的生成

intnum=(int)(Math.random()*6)+1;
//(int)(Math.random()*6)生成的是0~5之间的整数
//需要+1才是[1~6]的数字

• 关于次数统计的方案

  1, 可以使用HashMap<K,V>的方法进行存储统计. 因为key不重复,所以key可以来存数字1~6, 而对应的V就可以用来存储出现的次数

2. 可以使用数组的方法来存出现的次数. 数字1~6 是连续的, 数组下标也是连续的.我们可以用下标[0~5] 来代表数字[1~6], 数组的每个格子用来存数字数字出现的次数

• 完整的代码

//本题使用数组来写代码比较方便,简洁.
importjava.util.Random;

publicclassRandomDemo{
	publicstaticvoidmain(String[]args){
		int[]times=newint[6];//6个格子的数组,存储出现的次数
		intn=100;//循环的次数
		Randomr=newRandom();
		for(inti=0;i<n;i++){
			intnum=r.nextInt(6)+1;//方法1随机产生1~6的数字
			//intnum=(int)(Math.random()*6)+1;//方法2随机产生1~6的数字
			times[num-1]=times[num-1]+1;//次数增加1
		}
		
		for(inti=0;i<times.length;i++){
			System.out.println((i+1)+"出现的次数"+times[i]);
		}
	}
}

输出: 当n=100时

1出现的次数13
2出现的次数16
3出现的次数17
4出现的次数23
5出现的次数21
6出现的次数10

输出: 当n=1000时

1出现的次数160
2出现的次数177
3出现的次数161
4出现的次数169
5出现的次数175
6出现的次数158

• 结论:

  n=100时, 6是次数是10, 4次数是23, 两者的次数相差2倍多

  n=1000时, 6次数是158, 2次数是177, 两者比较接近

  说明: 当随机的次数越多. 那么随机数的概率也越来越接近~

④ java投掷骰子，求点数的出现概率

很简单 。
int [] num = new int[3]; //数组长度为3
int diag=0; //统计出现5的次数
for(int i=0;i>3;i++){ //掷骰子三次 ,也就是三个骰子
随机数字 num[i]=(int)(Math.random()*5)+1; //随机1-6的数字
if(num[i]==5){
diag++; //当骰子等于5的时候，统计次数加1；
}
}
double a=diag/3; //骰子出现5的次数，除以骰子总数，得到概率。
System.out.println(a);

⑤ java中如何以不同概率产生随机数1-30

Random rm = new Random();
int i = rm.nextInt(18);
int n = 0;
if(i > 8){
n = rm.nextInt(10)+1;
}else if(i > 2&&i <= 8){
n = rm.nextInt(11) + 10;
}else if(i<=2){
n = rm.nextInt(11) + 20;
}

这样生成的整数n是 3/6的概率在1-10之间，2/6的概率是在10-20之间，1/6的概率是在20-30之间(这种都是伪随机，但尽量接近概率)
你看看这样行不行
希望对你有帮助

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

• importjava.util.ArrayList;

• importjava.util.List;

• importjava.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】

• *

• */

• publicclassLotteryUtil{

• /**

• *定义一个连续集合

• *集合中元素x满足:(minElement,maxElement]

• *数学表达式为：minElement<x<=maxElement

• *

• */

• publicclassContinuousList{

• privatedoubleminElement;

• privatedoublemaxElement;

• publicContinuousList(doubleminElement,doublemaxElement){

• if(minElement>maxElement){

• ("区间不合理，minElement不能大于maxElement！");

• }

• this.minElement=minElement;

• this.maxElement=maxElement;

• }

• /**

• *判断当前集合是否包含特定元素

• *@paramelement

• *@return

• */

• publicbooleanisContainKey(doubleelement){

• booleanflag=false;

• if(element>minElement&&element<=maxElement){

• flag=true;

• }

• returnflag;

• }

• }

• privateList<ContinuousList>lotteryList;//概率连续集合

• privatedoublemaxElement;//这里只需要最大值，最小值默认为0.0

• /**

• *构造抽奖集合

• *@paramlist为奖品的概率

• */

• publicLotteryUtil(List<Double>list){

• lotteryList=newArrayList<ContinuousList>();

• if(list.size()==0){

• ("抽奖集合不能为空！");

• }

• doubleminElement=0d;

• ContinuousListcontinuousList=null;

• for(Doubled:list){

• minElement=maxElement;

• maxElement=maxElement+d;

• continuousList=newContinuousList(minElement,maxElement);

• lotteryList.add(continuousList);

• }

• }

• /**

• *进行抽奖操作

• *返回：奖品的概率list集合中的下标

• */

• publicintrandomColunmIndex(){

• intindex=-1;

• Randomr=newRandom();

• doubled=r.nextDouble()*maxElement;//生成0-1间的随机数

• if(d==0d){

• d=r.nextDouble()*maxElement;//防止生成0.0

• }

• intsize=lotteryList.size();

• for(inti=0;i<size;i++){

• ContinuousListcl=lotteryList.get(i);

• if(cl.isContainKey(d)){

• index=i;

• break;

• }

• }

• if(index==-1){

• ("概率集合设置不合理！");

• }

• returnindex;

• }

• publicdoublegetMaxElement(){

• returnmaxElement;

• }

• publicList<ContinuousList>getLotteryList(){

• returnlotteryList;

• }

• publicvoidsetLotteryList(List<ContinuousList>lotteryList){

• this.lotteryList=lotteryList;

• }

• }

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

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

[java]view plain

• packagecom.lottery;

• importjava.util.ArrayList;

• importjava.util.HashMap;

• importjava.util.List;

• importjava.util.Map;

• importjava.util.Map.Entry;

• classResult{

• privateintindex;

• privateintsumTime;

• privateinttime;

• privatedoubleprobability;

• privatedoublerealProbability;

• publicintgetIndex(){

• returnindex;

• }

• publicvoidsetIndex(intindex){

• this.index=index;

• }

• publicintgetTime(){

• returntime;

• }

• publicvoidsetTime(inttime){

• this.time=time;

• }

• publicintgetSumTime(){

• returnsumTime;

• }

• publicvoidsetSumTime(intsumTime){

• this.sumTime=sumTime;

• }

• publicdoublegetProbability(){

• returnprobability;

• }

• (){

• returnrealProbability;

• }

• publicvoidsetRealProbability(doublerealProbability){

• this.realProbability=realProbability;

• }

• publicResult(){

• }

• publicResult(intindex,intsumTime,inttime,doublerealProbability){

• this.setIndex(index);

• this.setTime(time);

• this.setSumTime(sumTime);

• this.setRealProbability(realProbability);

• }

• publicStringtoString(){

• return"索引值："+index+"，抽奖总数："+sumTime+"，抽中次数："+time+"，概率："

• +realProbability+"，实际概率："+(double)time/sumTime;

• }

• }

• publicclassTestLottery{

• staticfinalintTIME=100000;

• publicstaticvoiditeratorMap(Map<Integer,Integer>map,List<Double>list){

• for(Entry<Integer,Integer>entry:map.entrySet()){

• intindex=entry.getKey();

• inttime=entry.getValue();

• Resultresult=newResult(index,TIME,time,list.get(index));

• System.out.println(result);

• }

• }

• publicstaticvoidmain(String[]args){

• //构造概率集合

• List<Double>list=newArrayList<Double>();

• list.add(20d);

• list.add(80d);

• list.add(50d);

• list.add(30d);

• LotteryUtilll=newLotteryUtil(list);

• doublesumProbability=ll.getMaxElement();

• Map<Integer,Integer>map=newHashMap<Integer,Integer>();

• for(inti=0;i<TIME;i++){

• intindex=ll.randomColunmIndex();

• if(map.containsKey(index)){

• map.put(index,map.get(index)+1);

• }else{

• map.put(index,1);

• }

• }

• for(inti=0;i<list.size();i++){

• doubleprobability=list.get(i)/sumProbability;

• list.set(i,probability);

• }

• iteratorMap(map,list);

• }

• }


运行结果：




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

以下说明此类调用方式：

[java]view plain

• publicLotteryUtil(List<Double>list)

• 说明：构造方法，传入参数为一个概率集合

[java]view plain

• publicintrandomColunmIndex()

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

⑦ 求java算法：根据物品的数量来确定抽奖的概率(当物品数量为0时无论如何都不可能选到)

public class Lottery {

private int m = 1000;//发放奖券的数量
private int n = 2;//奖品的数量

public boolean getLottery(){
boolean isLottery = false;
double d = (double)n/(double)m;//中奖概率
double r = Math.random();//0~1之间的随机数，包括0
if(r<d){//如果随机数小于概率 那么中奖
n--;//奖品数量-1
isLottery = true;
}
m--;//奖券数量-1
return isLottery;
}

}