0
点赞
收藏
分享

微信扫一扫

随机数的生成,静态导入,可变参数的方法,方法重载,浮点数的比较

一,随机数产生方法

①最小值+Math.random() *(最大值-最小值+1):产生的数的范围在   [最小值,最大值] 

package com.java1;
import javax.swing.JOptionPane;

public class RandomInt {
public static void main( String args[] )
{
int value;
String output = "";

for ( int i = 1; i <= 20; i++ ) {
value = (int) ( 1+Math.random() * 6 );
output += value + " ";

if ( i % 5 == 0 )
output += "\n";
}

JOptionPane.showMessageDialog( null, output,
"20 Random Numbers from 1 to 6",
JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 );
}
}

产生的随机数的范围在1-6之间

随机数的生成,静态导入,可变参数的方法,方法重载,浮点数的比较_dom对象

 

 

new Random().nextInt(26)的方法来实现输出一个大于等于0,小于26的随机数

package com.java1;
import java.util.*;

public class TestRandom
{
public static void main(String[] args)
{
Random rand = new Random();
System.out.println("rand.nextBoolean():" + rand.nextBoolean());
byte[] buffer = new byte[16];
rand.nextBytes(buffer);
System.out.println(Arrays.toString(buffer));
//生成0.0~1.0之间的伪随机double数
System.out.println("rand.nextDouble():" + rand.nextDouble());
//生成0.0~1.0之间的伪随机float数
System.out.println("rand.nextFloat():" + rand.nextFloat());
//生成平均值是 0.0,标准差是 1.0的伪高斯数
System.out.println("rand.nextGaussian():" + rand.nextGaussian());
//生成一个处于long整数取值范围的伪随机整数
System.out.println("rand.nextInt():" + new Random().nextInt());
//生成0~26之间的伪随机整数
System.out.println("rand.nextInt(26):" + rand.nextInt(26));
//生成一个处于long整数取值范围的伪随机整数
System.out.println("rand.nextLong():" + rand.nextLong());
}
}

Answer:

rand.nextBoolean():true
[103, -90, -76, 58, -91, -52, -23, 45, 50, 73, -43, 70, 77, -64, -48, -122]
rand.nextDouble():0.1631898380376655
rand.nextFloat():0.1340416
rand.nextGaussian():-1.8408133377651577
rand.nextInt():-382427923
rand.nextInt(26):3
rand.nextLong():-1029091829791802274

③通过不同的种子来产生Random对象,和以当前时间为种子来产生Random对象

package com.java1;
import java.util.Random;

public class TestSeed
{
public static void main(String[] args)
{
Random r1 = new Random(50);
System.out.println("第一个种子为50的Random对象");
System.out.println("r1.nextBoolean():\t" + r1.nextBoolean());
System.out.println("r1.nextInt():\t\t" + r1.nextInt());
System.out.println("r1.nextDouble():\t" + r1.nextDouble());
System.out.println("r1.nextGaussian():\t" + r1.nextGaussian());
System.out.println("---------------------------");

Random r2 = new Random(50);
System.out.println("第二个种子为50的Random对象");
System.out.println("r2.nextBoolean():\t" + r2.nextBoolean());
System.out.println("r2.nextInt():\t\t" + r2.nextInt());
System.out.println("r2.nextDouble():\t" + r2.nextDouble());
System.out.println("r2.nextGaussian():\t" + r2.nextGaussian());
System.out.println("---------------------------");

Random r3 = new Random(100);
System.out.println("种子为100的Random对象");
System.out.println("r3.nextBoolean():\t" + r3.nextBoolean());
System.out.println("r3.nextInt():\t\t" + r3.nextInt());
System.out.println("r3.nextDouble():\t" + r3.nextDouble());
System.out.println("r3.nextGaussian():\t" + r3.nextGaussian());


Random r4 = new Random(System.currentTimeMillis());
System.out.println("以当前时间为种子的Random对象");
System.out.println("r3.nextBoolean():\t" + r4.nextBoolean());
System.out.println("r3.nextInt():\t\t" + r4.nextInt());
System.out.println("r3.nextDouble():\t" + r4.nextDouble());
System.out.println("r3.nextGaussian():\t" + r4.nextGaussian());
}
}

输出:

第一个种子为50的Random对象
r1.nextBoolean(): true
r1.nextInt(): -1727040520
r1.nextDouble(): 0.6141579720626675
r1.nextGaussian(): 2.377650302287946
---------------------------
第二个种子为50的Random对象
r2.nextBoolean(): true
r2.nextInt(): -1727040520
r2.nextDouble(): 0.6141579720626675
r2.nextGaussian(): 2.377650302287946
---------------------------
种子为100的Random对象
r3.nextBoolean(): true
r3.nextInt(): -1139614796
r3.nextDouble(): 0.19497605734770518
r3.nextGaussian(): 0.6762208162903859
以当前时间为种子的Random对象
r3.nextBoolean(): true
r3.nextInt(): 1678327555
r3.nextDouble(): 0.16760365386964127
r3.nextGaussian(): -0.7219839638959297

由结果我们可以知道:相同的种子产生的随机数是相同的,以当前时间为种子产生的随机数一定是独一无二的。

④手写代码来实现1000个随机数

根据公式:

随机数的生成,静态导入,可变参数的方法,方法重载,浮点数的比较_dom对象_02

 

 

 其中Xn=输入的种子数

 

 

c=0;  a=75=16807;  m=Integer.MAX_VALUE;

package com.randseed;
import java.lang.*;
import java.util.Scanner;
public class randseed {
public static void rand(long x)
{
long a;
for(int i=1;i<=1000;i++)
{
a=(x*16807)%Integer.MAX_VALUE;//由公式得
System.out.println(a);
x=a;
}
}

public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("请输入种子数:");
long seed;
seed=in.nextLong();
rand(seed);
}
}

输出1000个随机数。

二,静态导入

通过静态导入就不用再调用:类名.方法名,而是转换成直接使用方法名进行调用。

下面给出三种方式来解决abs绝对值的问题

package com.randseed;
import static java.lang.Math.*;
public class importstatic {

public static void Abs(int a)
{
if(a<0)
a=-a;
System.out.println(a);
}

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(abs(-100));//已经静态导入,故可以直接使用方法
System.out.println(Math.abs(-100));//数学函数本生就是静态的方法
Abs(-100);//自定义一个静态的方法
}
//三者结果都是相同的

三者输出结果都是:100

三,可变参数的方法

随机数的生成,静态导入,可变参数的方法,方法重载,浮点数的比较_Java学习笔记_03

利用可变参数的方法来计算传入的参数中最大值.

随机数的生成,静态导入,可变参数的方法,方法重载,浮点数的比较_dom对象_04

package com.java1;
import java.awt.*;
import java.awt.event.*;
import java.util.*;


public class VariableArgumentsTest{

public static double max(double...values)
{
double largest=Double.MIN_VALUE;
for (double v:values)
if(v>largest) largest=v;
return largest;
}

public static void main(String args[]) {

System.out.println("Max:"+max(1,11,300,2,3,50,1500,2010,2019));

}
}

输出为:2019

 四,方法重载的要点

重载关系的条件:

①方法名相同

②参数类型不同,参数个数不同,参数顺序不同

注意:方法的返回值不能作为判断的依据

package com.java1;
public class MethodOverload {

public static void main(String[] args) {
System.out.println("The square of integer 7 is " + square(7));
System.out.println("\nThe square of double 7.5 is " + square(7.5));
}

public static int square(int x) {
return x * x;
}

public static double square(double y) {
return y * y;
}
}

上述代码中:有两个square方法,但其参数类型不同,故而在调用时就会选择不同的方法名进行运算,

输出:

The square of integer 7 is 49

The square of double 7.5 is 56.25

五,浮点数的比较

在日常计算中难免会用到浮点数的比较,然而在浮点数之间的比较中能直接用==吗?

答案:否

不能直接用==来判断两个浮点数的值,而应该使用两数相减的绝对值小于一个极小的数,则两数相等。

package com.java1;


public class CompareFloatNumber {

/**
* @param args
*/
public static void main(String[] args) {
compare();
compare2();

}

private static void compare() {
double i = 0.0001;
double j = 0.00010000000000000001;
System.out.println(i==j); //输出:true
}
private static void compare2() {
double i = 0.0001;
double j = 0.000100000000600000001;
if(Math.abs(i-j)<1e-20){
System.out.println("true");
}
else
{
System.out.println("false");
}

}

}

输出:

true

false

因此,我们不能向比较整型一样来比较浮点数。

 



举报

相关推荐

0 条评论