random函数网站设计中random函数的作用

rand、rnd、random、randomize有什么区别？

楼主在哪看到C++里能用random,rnd这两个函数的？我只知道rand函数，是产生0-32768之间的随机整数的。

所以用rand()%n就可以生产0到n-1之间的随机整数。

想得到每次不同的结果，可以将系统时间作为randomize的参数来初始化，只要放在rand函数之前就行了。

详细介绍一下C语言里面的随机数产生函数random怎么用

rand()函数可以用来产生随机数e799bee5baa6e79fa5e98193e4b893e5b19e31333332643334，但是这不是真真意义上的随机数，是一个伪随机数，是根据一个数，我们可以称它为种了，为基准以某个递推公式推算出来的一系数，当这系列数很大的时候，就符合正态公布，从而相当于产生了随机数，但这不是真正的随机数，当计算机正常开机后，这个种子的值是定了的，除非你破坏了系统，为了改变这个种子的值，C提供了 srand()函数，它的原形是void srand( int a). ? 初始化随机产生器既rand()函数的初始值，即使把种子的值改成a; 从这你可以看到通过sand()函数，我们是可以产生可以预见的随机序列,那我们如何才能产生不可预见的随机序列呢？我们可能常常需要这样的随机序列，是吧。

利用srand((unsign)(time(NULL))是一种方法，因为每一次运行程序的时间是不同的. ? 下面讲一讲在C语言里所提供的随机数发生器的用法。

现在的C编译器都提供了一个基于ANSI标准的伪随机数发生器函数，用来生成随机数。

它们就是rand()和srand()函数。

这二个函数的工作过程如下： 1) 首先给srand()提供一个种子，它是一个unsigned int类型，其取值范围从0~65535； 2) 然后调用rand()，它会根据提供给srand()的种子值返回一个随机数(在0到32767之间) 3) 根据需要多次调用rand()，从而不间断地得到新的随机数； 4) 无论什么时候，都可以给srand()提供一个新的种子，从而进一步“随机化”rand()的输出结果。

以下是一个产生随机数的例子： 需要首先使用随机数“种子”初始化，srand函数： ＃i?nclude?<stdlib.h> ＃i?nclude?<stdio.h> ＃i?nclude?<time.h>//使用当前时钟做种子 void?main(?void?) { int?i; srand(?(unsigned)time(?NULL?)?);//初始化随机数 /*?打印10个随机数.?*/ for(?i?=?0;?i?<?10;i++?) printf(?"?%d ",?rand()?); } #include?<stdlib.h> #include?<time.h> main { int?i; srand(time(0));?//初始化随机种子 i?=?rand();?//产生随机数 }? 首先,加一个"#include<stdlib.h> 然后设一个变量,如j,j=rand(),就可以给j赋一个1~32767的随机数,如果要获得一个随机函数的十位(其它类似),只需令j=j%10就行. 添加头文件 #include<time.h> 然后在文件中添加 srand((unsigned)time(NULL)); srand()是用来初始化随机种子数的，因为rand的内部实现是用线性同余法做的，它不是真的随机数，只不过是因为其周期特别长，所以有一定的范围里可看成是随机的. 上面是有个随机种子的说明及方法,为了避免重复.然后再 用 随机函数,rand() 就行了. 头文件是 stdlib.h random() 产生随机数为 0或1 random(n) 产生随机数为 0到n之间的一个随机数? rand() 产生 0到32768之间的一个随机数 函数名: randomize 功 ?能: 初始化随机数发生器 用 ?法: void randomize(void); 程序例: #include?<stdlib.h> #include?<stdio.h> #include?<time.h> int?main(void) { ???int?i; ???randomize(); ???printf("Ten?random?numbers?from?0?to?99 "); ???for(i=0;?i<10;?i++) ???????printf("%d ",?rand()?%?100); ???return?0; }

请高人指教java中random函数的详细知识！本人不胜感激！谢谢了！

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.lang.Object 继承的方法 clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 构造方法详细信息 Random public Random()创建一个新的随机数生成器。

此构造方法为随机数生成器的种子设置某个值，该值与此构造方法的所有其他调用所用的值完全不同。

-------------------------------------------------------------------------------- Random public Random(long seed)使用单个 long 种子创建一个新随机数生成器： public Random(long seed) { setSeed(seed); }next 方法使用它来保存随机数生成器的状态。

参数： seed - 初始种子。

另请参见： setSeed(long) 方法详细信息 setSeed public void setSeed(long seed)使用单个 long 种子设置此随机数生成器的种子。

setSeed 的常规协定是它更改此随机数生成器对象的状态，使其状态好像是刚刚使用参数 seed 作为种子创建它的状态一样。

Random 类按如下方式实现 setSeed 方法： synchronized public void setSeed(long seed) { this.seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1); haveNextNextGaussian = false; }由 Random 类实现的 setSeed 恰好只使用 48 位的给定种子。

但是，通常重写方法可能使用 long 参数的所有 64 位作为种子值。

注：尽管种子值是一个基本的 AtomicLong，但仍必须对此方法同步，确保 haveNextNextGaussian 的语义正确。

参数： seed - 初始种子。

-------------------------------------------------------------------------------- next protected int next(int bits)生成下一个伪随机数。

当此数被所有其他方法使用时，子类应该重写此数。

next 的常规协定是它返回一个 int 值，并且如果参数位处于 1 和 32（包括）之间，那么返回值的多数低位都将（大致）是单独选择的位值，每个位值是 0 或 1 的机会（大致）相等。

Random 类按如下方式实现 next 方法： synchronized protected int next(int bits) { seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1); return (int)(seed >>> (48 - bits)); }这是一个线性同余伪随机数生成器，由 D. H. Lehmer 定义，Donald E. Knuth 在《The Art of Computer Programming, Volume 2: Seminumerical Algorithms》的第 3.2.1 节中进行了描述。

参数： bits - 随机位。

返回： 随机数生成器序列的下一个伪随机值。

从以下版本开始： JDK1.1 -------------------------------------------------------------------------------- nextBytes public void nextBytes(byte[] bytes)生成随机字节并将其置于用户提供的字节数组中。

所生成的随机字节数等于该字节数组的长度。

参数： bytes - 放入随机字节的非 null 字节数组。

从以下版本开始： JDK1.1 -------------------------------------------------------------------------------- nextInt public int nextInt()返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

nextInt 的常规协定是伪随机地生成并返回一个 int 值。

所有 232 个可能 int 值的生成概率（大致）相同。

Random 类按如下方式实现 nextInt 方法： public int nextInt() { return next(32); } 返回： 下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

-------------------------------------------------------------------------------- nextInt public int nextInt(int n)返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。

nextInt 的常规协定是伪随机地生成并返回指定范围中的一个 int 值。

所有 n 个可能 int 值的生成概率（大致）相同。

Random 类按如下方式实现 nextInt(int n) 方法： public int nextInt(int n) { if (n<=0) throw new IllegalArgumentException("n must be positive"); if ((n & -n) == n) // i.e., n is a power of 2 return (int)((n * (long)next(31)) >> 31); int bits, val; do { bits = next(31); val = bits % n; } while(bits - val + (n-1) < 0); return val; } 前面的描述中使用了不明确的词“大致”，只是因为 next 方法大致为一个单独选择位的公正来源。

如果它是一个随机选择位的最佳来源，那么给出的算法应该从起始范围开始完全一致地选择 int 值。

但此算法稍微有些复杂。

它拒绝那些会导致不均匀分布的值（由于 2^31 无法被 n 整除）。

某个值被拒绝的概率取决于 n。

最坏的情况是 n=2^30+1，拒绝的概率是 1/2，循环终止前的预计迭代次数是 2。

此算法特别对待 n 是 2 次幂的情况：它从基础的伪随机数生成器中返回正确的高位数。

在不是特殊处理的情况中，将返回正确的低 位数。

众所周知，线性同余伪随机数生成器（比如此类所实现的）在其低位的值序列中有 short periods。

因此，如果 n 是 2 次幂（幂值较小），则这种特殊情况会导致对此方法的后续调用会返回其长度大大增加的值序列。

参数： n - 所返回随机数的范围。

必须为正数。

返回： 一个伪随机数，处于 0（包括）和 n（包括）之间均匀分布的 int 值。

抛出： IllegalArgumentException - n 不是正数。

从以下版本开始： 1.2 -------------------------------------------------------------------------------- nextLong public long nextLong()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 long 值。

nextLong 的常规协定是伪随机地生成并返回一个 long 值。

所有 264 个可能 long 值的生成概率（大致）相同。

Random 类按如下方式实现 nextLong 方法： public long nextLong() { return ((long)next(32) << 32) + next(32); } 返回： 下一个伪随机数，它是此随机数生成器的序列中均匀分布的 long 值。

-------------------------------------------------------------------------------- nextBoolean public boolean nextBoolean()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、均匀分布的 boolean 值。

nextBoolean 的常规协定是伪随机地生成并返回一个 boolean 值。

值 true 和 false 的生成概率（大致）相同。

Random 类按如下方式实现 nextBoolean 方法： public boolean nextBoolean() {return next(1) != 0;} 返回： 下一个伪随机数，它是此随机数生成器的序列中均匀分布的 boolean 值。

从以下版本开始： 1.2 -------------------------------------------------------------------------------- nextFloat public float nextFloat()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。

nextFloat 的常规协定是伪随机地生成并返回一个从 0.0f（包括）到 1.0f（包括）范围内均匀选择（大致）的 float 值。

所有 224 个可能 float 值（其形式为 m x 2-24，其中 m 是一个小于 224 的正整数）的生成概率（大致）相同。

Random 类按如下方式实现 nextFloat 方法： public float nextFloat() { return next(24) / ((float)(1 << 24)); }前面的描述中使用了不明确的词“大致”，只是因为 next 方法大致为一个单独选择位的公正来源。

如果它是一个随机选择位的最佳来源，那么给出的算法应该从起始范围开始完全一致地选择 float 值。

[在 Java 的早期版本中，计算的结果是错误的，因为： return next(30) / ((float)(1 << 30));这可能看似等效（如果不是更好的话），但实际上由于浮点数舍入中的偏差，它会导致轻微的不均匀性：有效数的低位更可能是 0 而不是 1。

] 返回： 下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 float 值。

-------------------------------------------------------------------------------- nextDouble public double nextDouble()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0之间均匀分布的 double 值。

nextDouble 的常规协定是伪随机地生成并返回一个从 0.0d（包括）到 1.0d（包括）范围内均匀选择（大致）的 double 值。

所有 253 个可能 float 值（其形式为 m x 2-53，其中 m 是一个小于 253 的正整数）的生成概率（大致）相同。

Random 类按如下方式实现 nextDouble 方法： public double nextDouble() { return (((long)next(26) << 27) + next(27)) / (double)(1L << 53); }前面的描述中使用了不明确的词“大致”，只是因为 next 方法大致为一个单独选择位的公正来源。

如果它是一个随机选择位的最佳来源，那么给出的算法应该从起始范围开始完全一致地选择 double 值。

[在 Java 的早期版本中，计算的结果是错误的，因为： return (((long)next(27) << 27) + next(27)) / (double)(1L << 54);这可能看似等效（如果不是更好的话），但实际上由于浮点数舍入中的偏差，它会引入较大的不均匀性：有效数的低位可能出现的 0 是 1 的三倍！这种不均匀性在实践中可能没什么关系，但是我们应该争取完美。

] 返回： 下一个伪随机数，它是从此随机数生成器的序列中取出的、在 0.0 和 1.0 之间均匀分布的 double 值。

-------------------------------------------------------------------------------- nextGaussian public double nextGaussian()返回下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。

nextGaussian 的常规协定是伪随机地生成并返回一个 double 值，该值从（大致）从具有平均值 0.0 和标准偏差 1.0 的常规标准分布中选择。

Random 类按如下方式实现 nextGaussian 方法： synchronized public double nextGaussian() { if (haveNextNextGaussian) { haveNextNextGaussian = false; return nextNextGaussian; } else { double v1, v2, s; do { v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0 v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0 s = v1 * v1 + v2 * v2; } while (s >= 1 || s == 0); double multiplier = Math.sqrt(-2 * Math.log(s)/s); nextNextGaussian = v2 * multiplier; haveNextNextGaussian = true; return v1 * multiplier; } }这使用了 G. E. P. Box、M. E. Muller 和 G. Marsaglia 的 polar method，该方法在 Donald E. Knuth 的《The Art of Computer Programming, Volume 2:Seminumerical Algorithms》的第 3.4.1 节，小节 C，算法 P 中进行了描述。

注意，对于一次调用 Math.log 和一次调用 Math.sqrt 而言，它生成了两个单独的值。

返回： 下一个伪随机数，它是从此随机数生成器的序列中取出的、呈高斯（“正常地”）分布的 double 值，其平均值是 0.0，标准偏差是 1.0。

这是我从API里直接拷过来的，你可以在网上下载java api，网上有很多资源，有中文版的

网站设计中random函数的作用

var x=Math.random(); //生成一个0-1的随机数 var y=Math.round(x* 400); //得到一个0-400的随机数, 并进行四舍五入, 得到一个 0-400 的随机整数