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

一，随机数产生方法

①最小值+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之间

 

 

 ②利用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个随机数

根据公式：

 

 

 其中X_n=输入的种子数

 

 

c=0;　　a=7⁵=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

三，可变参数的方法

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

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

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

 

转载于:https://www.cnblogs.com/xiaofengzai/p/11585662.html