数值自动生成区间java算法

⑴ java中 如何产生一个特定范围的随机数

java.util
类 Random
java.lang.Object
java.util.Random
所有已实现的接口：
Serializable
直接已知子类：
SecureRandom

--------------------------------------------------------------------------------

public class Randomextends Objectimplements Serializable此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证属性的实现，为类 Random 指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。

Random 类所实现的算法使用一个 protected 实用工具方法，每次调用它都可提供最多 32 个伪随机生成的位。

很多应用程序会发现 Math 类中的 random 方法更易于使用。

从以下版本开始：
JDK1.0
另请参见：
Math.random(), 序列化表格

--------------------------------------------------------------------------------

构造方法摘要
Random()
创建一个新的随机数生成器。
Random(long seed)
使用单个 long 种子创建一个新随机数生成器： public Random(long seed) { setSeed(seed); } next 方法使用它来保存随机数生成器的状态。
方法摘要
protected int next(int bits)
生成下一个伪随机数。
boolean nextBoolean()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。
void nextBytes(byte[] bytes)
生成随机字节并将其置于用户提供的字节数组中。
double nextDouble()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的 double 值。
float nextFloat()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。
double nextGaussian()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。
int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n)
返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
long nextLong()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。
void setSeed(long seed)
使用单个 long 种子设置此随机数生成器的种子。
楼下的,直接说不理解有什么用

⑵ java 统计数字所属区间

intarray[]={1,2,101,220,1100,2300,1,10,230,220,2,1100};
		intarr2[]=null;//用数组存储array数组元素在各个区间个数
		intmax=0;//初始化最大值；
		
		//循环把数组最大值找出来
		for(inti=0;i<array.length;i++){
			if(array[i]>max){
				max=array[i];
			}
		}
		System.out.println("max:"+max);
		//计算区间个数，如何最大值不能整除100要增加一个区间
		if(max%100!=0){
			arr2=newint[(max/100+1)];
		}else{
			arr2=newint[(max/100)];
		}
		
		//循环array数组元素
		for(inti=0;i<array.length;i++){
			//循环arr2数组
			for(intj=0;j<arr2.length;j++){
				//判断array数组元素在那个区间段
				if(array[i]>=j*100+1&&array[i]<=(j+1)*100){
					arr2[j]++;
				}
			}
		}
		
		for(inti=0;i<arr2.length;i++){
			if(i==max/100){
				System.out.println("["+((i*100)+1)+"-"+(max)+"]:"+arr2[i]);
			}else{
				System.out.println("["+((i*100)+1)+"-"+((i+1)*100)+"]:"+arr2[i]);
			}
		}

随便写的，你尝试下吧

⑶ java 取范围内的随机数，比如取10000至99999

公式：Math.random()*(n-m)+m，生成大于等于m小于n的随机数
按公示取随机数10000至99999[10000,99999):
故:Math.random()*(99999-10000)+10000;

⑷ 如何用java生成指定范围的随机数

要生成在[min,max]之间的随机整数，
复制代码 代码如下:
package e.sjtu.erplab.io;
import java.util.Random;
public class RandomTest {
public static void main(String[] args) {
int max=20;
int min=10;
Random random = new Random();
int s = random.nextInt(max)%(max-min+1) + min;
System.out.println(s);
}
}
random.nextInt(max)表示生成[0,max]之间的随机数，然后对(max-min+1)取模。
以生成[10,20]随机数为例，首先生成0-20的随机数，然后对(20-10+1)取模得到[0-10]之间的随机数，然后加上min=10，最后生成的是10-20的随机数

⑸ java怎样将集合中的数值数据分区间统计个数：例如（0-1000）有几个人数据，1000-2000有几个数据

集合分组统计处理, 实现的方法很多,简单的写几种方法供参考;(理解后,自行扩展完善)

方法一:(Java8流处理粗略版) 该版本存在的问题:有些区间没有数据,就不打印显示该区间

importjava.util.*;
importjava.util.stream.*;

publicclassNumberDemo{
	publicstaticvoidmain(String[]args){
		
		ArrayList<Integer>list=newArrayList<Integer>();
		intnumbers=10;//集合里数字的个数
		intspace=1000;//区间的间隔

		//给集合里添加数字
		Randomrd=newRandom();
		for(inti=0;i<numbers;i++){
			list.add(rd.nextInt(5000));//集合里每个数字的范围是0~4999
		}

		funStream(list,space);
	}

	privatestaticvoidfunStream(ArrayList<Integer>list,intspace){
		//使用流处理把数字分组
		Map<String,List<Integer>>map=list.stream().collect(Collectors.groupingBy((num)->{
			return"区间:["+num/space*space+","+(num/space+1)*space+")";//分组规则
		}));
		map.forEach((k,v)->{
			System.out.println(k);
			System.out.println("	"+v.size()+"个数据");
		});
	}
}

方法二:(Java8流处理详细版) 就算有的区间是0个数据,照样打印出来

importjava.util.*;
importjava.util.stream.*;

publicclassNumberDemo2{
	publicstaticvoidmain(String[]args){
		ArrayList<Integer>list=newArrayList<Integer>();
		intnumbers=10;//集合里数字的个数
		intspace=1000;//区间的间隔

		//给集合里添加数字
		Randomrd=newRandom();
		for(inti=0;i<numbers;i++){
			list.add(rd.nextInt(5000));//集合里每个数字的范围是0~4999
		}

		funStream(list,space);
	}

	privatestaticvoidfunStream(ArrayList<Integer>list,intspace){
		//使用流处理把数字分组
		Map<Integer,List<Integer>>map=list.stream().collect(Collectors.groupingBy((num)->{
			returnnum/space;//分组规则
		}));
		
		//获取集合里的最大值
		Optional<Integer>maxop=list.stream().collect(Collectors.maxBy(Integer::compareTo));
		intmax=maxop.orElse(0);
		//计算出区间的数量
		intgroups=max%space==0?max/space:max/space+1;
		//打印结果
		for(inti=0;i<groups;i++){
			System.out.println("区间:["+i*space+","+(i+1)*space+")");
			System.out.println("	有"+(map.get(i)==null?0:map.get(i).size())+"个数据");
			//System.out.println("	"+map.get(i));//把数据打印出来
		}
	}
}

方法三:(比较传统的方法)

importjava.util.*;

publicclassNumberDemo3{
	publicstaticvoidmain(String[]args){
		ArrayList<Integer>list=newArrayList<Integer>();
		intnumbers=10;//集合里数字的个数
		intspace=1000;//区间的间隔

		//给集合里添加数字
		Randomrd=newRandom();
		for(inti=0;i<numbers;i++){
			list.add(rd.nextInt(5000));//集合里每个数字的范围是0~4999
		}
		
		fun(list,space);
	}
	privatestaticvoidfun(ArrayList<Integer>list,intspace){
		Collections.sort(list);//排序
		intmax=list.get(list.size()-1);//取得最大值
		intgroups=max%space==0?max/space:max/space+1;//取得区间的数量
		HashMap<Integer,ArrayList<Integer>>map=newHashMap<Integer,ArrayList<Integer>>();//存区间和该区间的数字
		for(inti=0;i<groups;i++){
			map.put(i,newArrayList<>());
		}
		//把元素添加到指定的区间
		for(inti=0;i<list.size();i++){
			map.get(list.get(i)/space).add(list.get(i));
		}
		//打印结果
		for(inti=0;i<groups;i++){
			System.out.println("区间:["+i*space+","+(i+1)*space+")");
			System.out.println("	有"+map.get(i).size()+"个数据");
			//System.out.println("	"+map.get(i));//把数据打印出来
		}
	}
}

测试效果如下

区间:[0,1000)
	有5个数据
区间:[1000,2000)
	有0个数据
区间:[2000,3000)
	有1个数据
区间:[3000,4000)
	有2个数据
区间:[4000,5000)
	有2个数据

⑹ JAVA中如何产生一个特定范围的随机数

生成0-2之间的随机数，包括2

Random rand = new Random();

int randNum = rand.nextInt(3);

生成5-26之间的随机数，包括26

int randNum = rand.nextInt(22)+5;

⑺ 在JAVA中 产生一个随机数时，如何让产生的数值在某一个范围内，并举例说明。

比如产生 5~15的随机数
int num=(Math.abs(new Random().nextInt()))%11+5;

这种方法就可以。

⑻ Java编程中如何在一个数值范围内生成一个伪

intstart=5,end=15;
//比如5~15，随机范围数的长度是10（15减5）生成的0到10之间得数加上5就是5到15之间
Randomr=newRandom();
r.nextInt(end-start)+start;

//同理Math.ramdom()得到的是0到1之间的小数
//乘上整数就得到0到该数值之间的数，再加上整数就得到该区间的数
//5~1515-5之间有10个数，就从0到10之间随机生成，再加上5；
Math.ramdom()*(end-start)+start;

⑼ java怎么进行随机数生成算法

要产生随机数，可以使用Java api中java.lang包中的Math类.Math类以静态方法的方式提供常用的数学方法，
其中Math.random()方法是一个可以产生[0.0,1.0]区间内的一个双精度浮点数的方法
如：
产生一个100以内的整数：int x=(int)(Math.random()*100);
又如：
产生一个1-50之间的随机数：int x=1+(int)(Math.random()*50)
也可以使用通用创建对象来获取：
Random random = new Random();
random.nextInt(x);
产生一个0到x-1的正数，如果想产生浮点数有Random类的nextFloat方法，总之nextXXX方法是用来产生随机数的。

⑽ 怎样用java产生一个指定范围的随机数

java.util
类 Random
java.lang.Object
java.util.Random
所有已实现的接口：
Serializable
直接已知子类：
SecureRandom

--------------------------------------------------------------------------------

public class Randomextends Objectimplements Serializable此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。

如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证属性的实现，为类 Random 指定了特定的算法。为了 Java 代码的完全可移植性，Java 实现必须让类 Random 使用此处所示的所有算法。但是允许 Random 类的子类使用其他算法，只要其符合所有方法的常规协定即可。

Random 类所实现的算法使用一个 protected 实用工具方法，每次调用它都可提供最多 32 个伪随机生成的位。

很多应用程序会发现 Math 类中的 random 方法更易于使用。

从以下版本开始：
JDK1.0
另请参见：
Math.random(), 序列化表格

--------------------------------------------------------------------------------

构造方法摘要
Random()
创建一个新的随机数生成器。
Random(long seed)
使用单个 long 种子创建一个新随机数生成器： public Random(long seed) { setSeed(seed); } next 方法使用它来保存随机数生成器的状态。
方法摘要
protected int next(int bits)
生成下一个伪随机数。
boolean nextBoolean()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。
void nextBytes(byte[] bytes)
生成随机字节并将其置于用户提供的字节数组中。
double nextDouble()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的 double 值。
float nextFloat()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。
double nextGaussian()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。
int nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n)
返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
long nextLong()
返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。
void setSeed(long seed)
使用单个 long 种子设置此随机数生成器的种子。
楼下的,直接说不理解有什么用