精华内容
下载资源
问答
  • RandomAccessFile( “C:/MyFile1/Test.java” ,”wr”) 30、当使用FileInputStream类中的read()方法时,如果没有读入 一个字节数据时,返回值为( ) D A、0......3. Coding: Implement the solution in Java. 4. ...

    RandomAccessFile( “C:/MyFile1/Test.java” ,”wr”) 30、当使用FileInputStream类中的read()方法时,如果没有读入 一个字节数据时,返回值为( ) D A、0......

    3. Coding: Implement the solution in Java. 4. Testing: Make sure that the numbers appear random. Submit the screen shots of two sample runs. 4.测试......

    (2)编写 Java 应用程序,运用 RandomAccessFile 类对文件进行随机读写。 实训要求: 掌握从键盘读取各种数据的方法与技巧;掌握随机读写文件类的应用技巧。 5.GUI ......

    [解析] random ()方法是java.lang.Math类中求随机数的方法;abs ()方法是java.lang.Math类中求绝对值的方法;sin ()方法是java.lang.Math类中求正弦函数的方......

    3.使用 Math.random()方法产生 的随机整数, 3.使用 Math.random()方法产生 50 个 0—100 的随机整数, 并将它们存放到一维数组 score 然后统计各分数段上的......

    6.1.1 String类的初始化 返回目录 – Java中定义了String和StringBuffer两个类来封装字符串,并提供 了一系列操作字符串的方法,它们都位于ng包中,因此不......

    (int)Math.random()*999 . . D. 20+(int)Math.random()*980 (C)7、以下 Math 类的方法中,-4.4 通过哪个方法运算后,结果 为-5.0? A. round()四舍......

    Java 中的特殊类,包含常量和抽象方法 关于内部类下列说法不正确的是( A ) 内部类不能有自己的成员方法和成员变量 内部类可用 abstract 修饰定义为抽象类,也可以......

    三、随机数产生方法 ① java.lang.Math .Random()静态方法 Math.random()*1000);//产生 0-1000 的整数随机数 2 创建 java.util.Random 对象 Random random=......

    在 Java 语言中,所有的数组都有一个 lenght 属性,这个属性存储了该数组 的;二、选择题 1、有整型数组:int[] x={12,35,8,7,2};,则调用方法 Arrays.......

    (s1); } 随机函数的使用: 随机函数: Math.random() 数组的输出模块: for(i=0;i<20;i=i+1) { } 返回[0,1.0) 之间的随机数。 0<=Math.random()......

    Java中Arrays的sort方法汇总_计算机软件及应用_IT/计算机_专业资料。1 Java 中 Arrays 的 sort 方法 数组的排序,Java 自带的 Arrays 类的 sort 方法主要内容......

    用于文件的随机读写操作的文件类是 45. Java 中的多态为编译时多态和运行时多态两类。 RandomAccessFile。 46. 对象的类型转换分为 upcasting 和 casting ......

    ( ) A.long B.sizeof C.class D.const 14、在 Java 中,一个类可同时定义许多同名的方法,这些方法的形式参数个 数、类型或顺序各不相同,传回的值也可以不......

    第九章 线程 目录 Java中的线程 线程的生命周期 Thread的子类创建线程 使用Runable接口 线程的常用方法 线程的优先级 线程同步 在同步方法中使用wait()、notify 和......

    19. 20. Java 语言是平台无关的语言。T 类的静态方法中可以访问该类的非静态数据成员.F Java 中方法调用时参数传递都是按值传递的, 因此从方法中退出时, ......

    2. Java 中的变量可分为两种数据类型,分别是 ___ 基本数据类型 _ 和 _ 引用数据类型 __ ___。 3. 在非静态成员方法中,可以使用关键字__ This _ ___......

    下列关于 main()方法正确的是___。 A. main()方法是程序运行入口,所以每一.java的源程序都有main()方法; B. 在main()方法中直接调用的方法必须是静态方法......

    Java试题_IT认证_资格考试/认证_教育专区。计算机 一、选择 1.欲构造 ArrayList 类的一个实例,此类继承了 List 接口,下列哪个方法是正确的? AArrayListmyList=......

    JAVA试题4_IT认证_资格考试/认证_教育专区。1. 要从文件""中读出第 10 个字节到变量 c 中,下列哪个方法适合? (D) A、 in=new (""); in.skip(9); ......

    展开全文
  • java使用random函数方法

    2020-07-21 09:52:06
    //使用Math类madom方法,返回值为 double值为正号,大于等于 0.0 ,小于 1.0 。 返回的值是从该范围(大约)均匀分布而伪随机选择的。 System.out.println(Math.random()); Random random = new Random(); //返回下一...
    1. Math.random()是Math类的一个静态方法,线程安全,与Random类的nextDouble()方法类似
    2. 代码
    //使用Math类madom方法,返回值为 double值为正号,大于等于 0.0 ,小于 1.0 。 返回的值是从该范围(大约)均匀分布而伪随机选择的。
    System.out.println(Math.random());
    Random random = new Random();
    //返回下一个伪随机数[0.0,1.0)
    System.out.println(random.nextDouble());
    // nextBoolean的一般合同是一个boolean值被伪随机生成并返回。 true和false以(大概)相等的概率产生。
    System.out.println(random.nextBoolean());
    //返回下一个均匀分布float之间的值0.0和1.0从这个随机数生成器的序列
    System.out.println(random.nextFloat());
    //所有2^32可能的int值以(大约)相等的概率产生
    System.out.println(random.nextInt());
    //返回伪随机的,均匀分布int值介于0(含)和指定值(不包括),从该随机数生成器的序列绘制
    System.out.println(random.nextInt(10));
    //使用单个long种子创建新的随机数生成器。 种子是通过方法next(int)维护的伪随机数发生器的内部状态的初始值
    Random random1 = new Random(2);
    //每次第一次生成的值都是-1154715079,每次生成的数组序列相同
    System.out.println(random1.nextInt());
    System.out.println(random1.nextInt());
    

    返回结果:

    0.8032510201122399
    0.3044412199449481
    true
    0.20410597
    1115498252
    4
    -1154715079
    1260042744
    
    展开全文
  • Collection工具类与Random函数Java

    千次阅读 2020-01-30 08:42:03
    Collection工具类 Collection工具类为操作List集合提供了...小例子: 使用shuffle(),方法模拟洗牌操作,并输出。c简单的斗地主洗牌发牌的程序: import java.util.Arrays; import java.util.Random; public clas...

    Collection工具类

    Collection工具类为操作List集合提供了几个有用的方法:
    reverse()、shuffle()、sort()、swap()、rotate()。

    小例子: 使用shuffle(),方法模拟洗牌操作,并输出。c简单的斗地主洗牌发牌的程序:

    import java.util.Arrays;
    import java.util.Random;
    
    public class PokerGame {
        //1.创建数组,用以存储扑克牌
        static String[] pokers = new String[54];    
        public static void main(String[] args) {        
            //2.创建牌  所有的牌赋值到array数组中
            pokers = newPoker();
            //3.洗牌  这里的实参pokers是经过创建牌之后新生成的pokers
            String[] pokers2 = upsetPoker(pokers);
            //4.发牌       
            sendPoker(pokers2);
    }
        //创建牌的方法
        public static String[] newPoker() {
            //1.定义花色数组
            String[] colors = {"红桃","黑桃","梅花","方片"};
            //2.定义牌面数组
            String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
            //3.定义王
            String[] kings = {"大王","小王"};
            //4.使用循环将牌存储到pokers数组
            int index = 0;
            for(int i = 0 ; i < numbers.length ; i ++) {
                for(int j = 0 ; j < colors.length ; j ++) {
                    pokers[index ++] = colors[j] + numbers[i];
                }
            }
            //5.大小王拷贝入pokers数组
            System.arraycopy(kings, 0, pokers, index, 2);
            //6.输出牌
            System.out.println("现有一副扑克牌" + Arrays.toString(pokers) + "\n");  
            return pokers;
        }   
        //洗牌的方法
        public static String[] upsetPoker(String[] array) {
            //1.定义新的数组,用以存储洗好的牌
            String[] newpokers = new String[pokers.length];
            //2.定义数组,用以标识被随机取出的牌
            boolean[] mark = new boolean[pokers.length];        
            //3.洗牌
            for(int i = 0 ; i < pokers.length ; i ++) {
                //a.创建随机数
                Random rd = new Random();
                //b.获取随机数的下标
                int index = rd.nextInt(pokers.length);
                //c.判断标识
                if(mark[index] == false) {
                    //d.将未洗过的牌存储入newpokers
                    newpokers[i] = pokers[index];
                    //e.修改标识,被洗过的牌标记为true
                }else {
                    i --; //该次取随机数取到的是洗过的牌,则重新再取一次
                }
            }      
            //newpokers内的牌拷贝到数组pokers
            pokers = Arrays.copyOf(newpokers, newpokers.length);
            System.out.println("洗过的牌:" + Arrays.toString(newpokers)+"\n");
            return newpokers;
        }    
        //发牌的方法
        public static void sendPoker(String[] array) {
            //1.定义玩家及底牌数组
            String[] one = new String[0];
            String[] two = new String[0];
            String[] three = new String[0];
            String[] underpoker = new String[3];
            
            //2.循环进行发牌
            for(int i = 0 ; i < pokers.length-3 ; i++) {
                if(i % 3 == 0) {
                    one = Arrays.copyOf(one, one.length+1);
                    one[one.length-1] = pokers[i];
                }else if(i % 3 == 1) {
                    two = Arrays.copyOf(two, two.length+1);
                    two[two.length-1] = pokers[i];
                }else if(i % 3 == 2) {
                    three = Arrays.copyOf(three, three.length+1);
                    three[three.length-1] = pokers[i];
                }
            }   
            System.arraycopy(pokers, pokers.length-3, underpoker, 0, 3);       
            System.out.println("玩家1:" + Arrays.toString(one));
            System.out.println("玩家2:" + Arrays.toString(two));
            System.out.println("玩家3:" + Arrays.toString(three));
            System.out.println("底牌:" + Arrays.toString(underpoker));
        }
    }
    

    JAVA中的Random()函数

    Java中存在着两种Random函数:

    一、java.lang.Math.Random;

    调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。
    案例:

    package IO;
    import java.util.Random;
    
    public class TestRandom {   
        public static void main(String[] args) {
            // 案例1
            System.out.println("Math.random()=" + Math.random());// 结果是个double类型的值,区间为[0.0,1.0)
            int num = (int) (Math.random() * 3); // 注意不要写成(int)Math.random()*3,这个结果为0,因为先执行了强制转换
            System.out.println("num=" + num);
            /**
             * 输出结果为:
             * 
             * Math.random()=0.02909671613289655
             * num=0
             * 
             */  }}
    

    二、java.util.Random

    下面Random()的两种构造方法:
    Random():创建一个新的随机数生成器。
    Random(long seed):使用单个 long 种子创建一个新的随机数生成器。
    我们可以在构造Random对象的时候指定种子(这里指定种子有何作用,请接着往下看),如:Random r1 = new Random(9);
    或者默认当前系统时间的毫秒数作为种子数:Random r1 = new Random();
    需要说明的是:你在创建一个Random对象的时候可以给定任意一个合法的种子数,种子数只是随机算法的起源数字,和生成的随机数的区间没有任何关系。
    new Random(9);初始化时9并没有起直接作用(注意:不是没有起作用),rand.nextInt(100);中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。

    具体用法如下例:

    import java.util.ArrayList;
    import java.util.Random;
    public class TestRandom {
        public static void main(String[] args) {
            // 案例2
            // 对于种子相同的Random对象,生成的随机数序列是一样的。
            Random ran1 = new Random(10);
            System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");
            for (int i = 0; i < 10; i++) {
                System.out.print(ran1.nextInt(10) + " ");
            }
            System.out.println();
            Random ran2 = new Random(10);
            System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");
            for (int i = 0; i < 10; i++) {
                System.out.print(ran2.nextInt(10) + " ");
            }
            /**
             * 输出结果为:
             * 
             * 使用种子为10的Random对象生成[0,10)内随机整数序列: 
             * 3 0 3 0 6 6 7 8 1 4 
             * 使用另一个种子为10的Random对象生成[0,10)内随机整数序列: 
             * 3 0 3 0 6 6 7 8 1 4 */
            // 案例3
            // 在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
            Random r3 = new Random();
            System.out.println();
            System.out.println("使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列");
            for (int i = 0; i < 10; i++) {
                System.out.print(r3.nextInt(10)+" ");
            }
            /* 输出结果为:
             * 使用种子缺省是当前系统时间的毫秒数的Random对象生成[0,10)内随机整数序列
             * 1 1 0 4 4 2 3 8 8 4
             */
            // 另外,直接使用Random无法避免生成重复的数字,如果需要生成不重复的随机数序列,需要借助数组和集合类
            ArrayList list=new TestRandom().getDiffNO(10);
            System.out.println();
            System.out.println("产生的n个不同的随机数:"+list);
        }
        /* 生成n个不同的随机数,且随机数区间为[0,10)
         * @param n
         * @return     */
        public ArrayList getDiffNO(int n){
            // 生成 [0-n) 个不重复的随机数
            // list 用来保存这些随机数
            ArrayList list = new ArrayList();
            Random rand = new Random();
            boolean[] bool = new boolean[n];
            int num = 0;
            for (int i = 0; i < n; i++) {
                do {
                    // 如果产生的数相同继续循环
                    num = rand.nextInt(n);
                } while (bool[num]);
                bool[num] = true;
                list.add(num);
            }
            return list;
        }
    }
    

    下面是Java.util.Random()方法摘要:

    1.protected int next(int bits):生成下一个伪随机数。
    2.boolean nextBoolean():返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的boolean值。
    3.void nextBytes(byte[] bytes):生成随机字节并将其置于用户提供的 byte 数组中。
    4.double nextDouble():返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
    5.float nextFloat():返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
    6.double nextGaussian():返回下一个伪随机数,它是取自此随机数生成器序列的、呈高斯(“正态”)分布的double值,其平均值是0.0标准差是1.0。
    7.int nextInt():返回下一个伪随机数,它是此随机数生成器的序列中均匀分布的 int 值。
    8.int nextInt(int n):返回一个伪随机数,它是取自此随机数生成器序列的、在(包括和指定值(不包括)之间均匀分布的int值。
    9.long nextLong():返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的 long 值。
    10.void setSeed(long seed):使用单个 long 种子设置此随机数生成器的种子。

    下面给几个例子:
    生成[0,1.0)区间的小数:double d1 = r.nextDouble();
    生成[0,5.0)区间的小数:double d2 = r.nextDouble() * 5;
    生成[1,2.5)区间的小数:double d3 = r.nextDouble() * 1.5 + 1;
    生成-231到231-1之间的整数:int n = r.nextInt();
    生成[0,10)区间的整数:
      int n2 = r.nextInt(10);//方法一
      n2 = Math.abs(r.nextInt() % 10);//方法二

    展开全文
  • Java--Random函数

    2021-07-18 00:00:50
    Java中存在着两种Random函数: 1.1 java.lang.Math.Random() 调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,...

    1. Random函数

    Java中存在着两种Random函数:


    1.1 java.lang.Math.Random()

    调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。例子如下:
    在这里插入图片描述


    1.2 java.util.Random类

    下面是Random的两种构造方法:

    • Random():创建一个新的随机数生成器。
    • Random(long seed):使用单个 long 种子创建一个新的随机数生成器。

    你在创建一个Random对象的时候可以给定任意一个合法的种子数,种子数只是随机算法的起源数字,和生成的随机数的区间没有任何关系。

    演示一

    • 在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。
    • rand.nextInt(100)中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。
        public static void main(String[] args) {
            Random rand = new Random();
            int i = rand.nextInt(100);
            System.out.println(i);
        }
    

    演示二

    对于种子相同的Random对象,生成的随机数的范围是一样的。

        public static void main(String[] args) {
            Random ran1 = new Random(25);
            System.out.println("使用种子为25的Random对象生成[0,100)内随机整数序列: ");
            for (int i = 0; i < 10; i++) {
                System.out.print(ran1.nextInt(100) + " ");
            }
            System.out.println();
        }
    

    在这里插入图片描述

    方法摘要

    在这里插入图片描述

    例子

    在这里插入图片描述



    展开全文
  • Java - 常用函数Random函数

    万次阅读 2015-03-18 16:02:38
    Java的API帮助文档中,总结了一下对这个Random()函数功能的描述: 1、java.util.Random类中实现的随机算法是伪随机,也就是有规则的随机,所谓有规则的就是在给定种(seed)的区间内随机生成数字; 2、相同种子数的...
  • 原博文2016-12-01 11:46 −如果你对在Python生成随机数与random模块中最常用的几个函数的关系与不懂之处,下面的文章就是对Python生成随机数与random模块中最常用的几个函数的关系,希望你会有所收获,以下就是这篇...
  • Java的Random类和Random函数
  • JavaRandom函数介绍

    千次阅读 2019-03-14 14:54:50
    Java中存在两种Random函数: 一.java.lang.Math.Random Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似...
  • Random()函数生成随机数 ...在Java的API帮助文档中,总结了一下对这个Random()函数功能的描写叙述: 1、java.util.Random类中实现的随机算法是伪随机,也就是有规则的随机,所谓有规则的就是在给定种(se...
  • Java Random() 函数使用方法

    万次阅读 多人点赞 2019-05-20 15:01:20
    import java.util.Random; public class Graphics { public static void main(String[] args) { Random r = new Random();//(方法一)先生成一个对象 r, int b= r.nextInt(10); //调用 r 对象下面的nextInt,...
  • Java中的random函数

    2019-01-11 21:58:43
    Java中的random函数
  • Python标准库中的random函数,可以生成随机浮点数、整数、字符串,甚至帮助你随机选择列表序列中的一个元素,打乱一组数据等。random中的一些重要函数的用法:1 )、random() 返回0...
  • java中的random函数

    2018-03-20 12:40:58
    java中存在两种Random函数:1.java.lang.Math.Random2.java.util.Random下面先介绍一下第一种:调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开...
  • java中的Random函数

    2014-12-11 10:13:55
    今天在做Java练习的时候注意到了Java里面的一个随机函数——Random,刚开始只是知道这个函数具有随机取值的作用,于是上网搜索了资料一番,做了一下一些关于Random函数的总结: Java中存在着两种Random函数...
  • Java中存在着两种Random函数: 一、java.lang.Math.Random;  调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,...
  • java随机函数用法Random

    万次阅读 2010-11-12 11:20:00
    import java.util....// 使用java.lang.Math的random方法生成随机数 System.out.println("Math.random(): " + Math.random()); // 使用不带参数的构造方法构造java.util.Random对象 System.out.println
  • Java Random 函数 一、Random()函数 Java中提供两种Random()函数: ####1、java.lang.Math.Random; 调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右...
  • Java中存在着两种Random函数分别是java.lang.Math.Random和java.util.Random,文中给大家介绍了random()的两种构造方法,感兴趣的朋友跟随小编一起看看吧
  • 觉得很好,于是引用 感谢佚名创作。 RANDOM(我最先想到的是彩票。。。) ...import java.util.Random;...public class RandomNumber{ ...// 使用java.lang.Math的random方法生成随机数 System.out.println("Mat
  • JavaRandom函数的总结

    千次阅读 2014-03-19 10:23:32
    Java中存在着两种Random函数: 一、java.lang.Math.Random; 调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,...
  • 两种Random函数使用

    2021-05-17 22:33:53
    Java中存在着两种Random函数java.lang.Math.Random以及java.util.Random); 因为在日常的使用中,常常会涉及到随机数的产生,例如本次快递E站中的取件码随机生成,就需要产生一个随机数:code 下面是产生随机数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,057
精华内容 32,822
关键字:

random函数用法java

java 订阅