Java/Development Class/Random

Материал из Java эксперт
Перейти к: навигация, поиск

A wrapper that supports all possible Random methods via the java.lang.Math#random() method and its system-wide {@link Random} object.

   <source lang="java">

/*

* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*/

import java.util.Random; /**

*

JVMRandom is a wrapper that supports all possible * Random methods via the {@link java.lang.Math#random()} method * and its system-wide {@link Random} object.

* 
* @since 2.0
* @version $Id: JVMRandom.java 471626 2006-11-06 04:02:09Z bayard $
*/

public final class JVMRandom extends Random {

   /**
    * Required for serialization support.
    * 
    * @see java.io.Serializable
    */
   private static final long serialVersionUID = 1L;
   /**
    * Ensures that only the constructor can call reseed.
    */
   private boolean constructed = false;
   /**
    * Constructs a new instance.
    */
   public JVMRandom() {
       this.constructed = true;
   }
   
   /**
    * Unsupported in 2.0.
    * 
    * @param seed ignored
    * @throws UnsupportedOperationException
    */
   public synchronized void setSeed(long seed) {
       if (this.constructed) {
           throw new UnsupportedOperationException();
       }
   }
   /**
    * Unsupported in 2.0.
    * 
    * @return Nothing, this method always throws an UnsupportedOperationException.
    * @throws UnsupportedOperationException
    */
   public synchronized double nextGaussian() {
       throw new UnsupportedOperationException();
   }
   /**
    * Unsupported in 2.0.
    * 
    * @param byteArray ignored
    * @throws UnsupportedOperationException
    */
   public void nextBytes(byte[] byteArray) {
       throw new UnsupportedOperationException();
   }
   /**
*

Returns the next pseudorandom, uniformly distributed int value * from the Math.random() sequence.

    *
    * @return the random int
    */
   public int nextInt() {
       return nextInt(Integer.MAX_VALUE);
   }
   /**
*

Returns a pseudorandom, uniformly distributed int value between * 0 (inclusive) and the specified value (exclusive), from * the Math.random() sequence.

    *
    * @param n  the specified exclusive max-value
    * @return the random int
    * @throws IllegalArgumentException when n <= 0
    */
   public int nextInt(int n) {
       if (n <= 0) {
           throw new IllegalArgumentException(
               "Upper bound for nextInt must be positive"
           );
       }
       // TODO: check this cannot return "n"
       return (int)(Math.random() * n);
   }
   /**
*

Returns the next pseudorandom, uniformly distributed long value * from the Math.random() sequence.

    * @return the random long
    */
   public long nextLong() {
       // possible loss of precision?
       return nextLong(Long.MAX_VALUE);
   }
   /**
*

Returns a pseudorandom, uniformly distributed long value between * 0 (inclusive) and the specified value (exclusive), from * the Math.random() sequence.

    *
    * @param n  the specified exclusive max-value
    * @return the random long
    * @throws IllegalArgumentException when n <= 0
    */
   public static long nextLong(long n) {
       if (n <= 0) {
           throw new IllegalArgumentException(
               "Upper bound for nextInt must be positive"
           );
       }
       // TODO: check this cannot return "n"
       return (long)(Math.random() * n);
    }
   /**
*

Returns the next pseudorandom, uniformly distributed boolean value * from the Math.random() sequence.

    *
    * @return the random boolean
    */
   public boolean nextBoolean() {
       return Math.random() > 0.5;
   }
   /**
*

Returns the next pseudorandom, uniformly distributed float value * between 0.0 and 1.0 from the Math.random() * sequence.

    *
    * @return the random float
    */
   public float nextFloat() {
       return (float)Math.random();
   }
   /**
*

Synonymous to the Math.random() call.

    *
    * @return the random double
    */
   public double nextDouble() {
       return Math.random();
   }
   

}

 </source>
   
  
 
  



Create random number

   <source lang="java">
 

public class Main {

 public static void main(String[] args) {
   double number = Math.random();
   System.out.println("Generated number: " + number);
   number = Math.random() * 10;
   System.out.println("Generated number: " + number);
   number = 100 + (Math.random() * 100);
   System.out.println("Generated number: " + number);
   int random = 100 + (int) (Math.random() * 100);
   System.out.println("Generated number: " + random);
 }

}


 </source>
   
  
 
  



Create two random number generators with the same seed

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   long seed = rand.nextLong();
   rand = new Random(seed);
   Random rand2 = new Random(seed);
 }

}


 </source>
   
  
 
  



Does Math.random() produce 0.0 and 1.0

   <source lang="java">
 

//: c03:RandomBounds.java // Does Math.random() produce 0.0 and 1.0? // {RunByHand} // From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002 // www.BruceEckel.ru. See copyright notice in CopyRight.txt. public class RandomBounds {

 static void usage() {
   System.out.println("Usage: \n\t" +
     "RandomBounds lower\n\tRandomBounds upper");
   System.exit(1);
 }
 public static void main(String[] args) {
   if(args.length != 1) usage();
   if(args[0].equals("lower")) {
     while(Math.random() != 0.0)
       ; // Keep trying
     System.out.println("Produced 0.0!");
   }
   else if(args[0].equals("upper")) {
     while(Math.random() != 1.0)
       ; // Keep trying
     System.out.println("Produced 1.0!");
   }
   else
     usage();
 }

} ///:~



 </source>
   
  
 
  



Generate a random array of numbers

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] args) {
   Random r = new Random();
   // generate some random boolean values
   boolean[] booleans = new boolean[10];
   for (int i = 0; i < booleans.length; i++) {
     booleans[i] = r.nextBoolean();
   }
   for (boolean b : booleans) {
     System.out.print(b + ", ");
   }
   // generate a uniformly distributed int random numbers
   int[] integers = new int[10];
   for (int i = 0; i < integers.length; i++) {
     integers[i] = r.nextInt();
   }
   for (int i : integers) {
     System.out.print(i + ", ");
   }
   // generate a uniformly distributed float random numbers
   float[] floats = new float[10];
   for (int i = 0; i < floats.length; i++) {
     floats[i] = r.nextFloat();
   }
   for (float f : floats) {
     System.out.print(f + ", ");
   }
   // generate a Gaussian normally distributed random numbers
   double[] gaussians = new double[10];
   for (int i = 0; i < gaussians.length; i++) {
     gaussians[i] = r.nextGaussian();
   }
   for (double d : gaussians) {
     System.out.print(d + ", ");
   }
 }

}


 </source>
   
  
 
  



Generate random ints by asking Random() for

   <source lang="java">
 

import java.util.*; /** Generate random ints by asking Random() for

* a series of random integers from 1 to 10, inclusive.
*
* @author Ian Darwin, http://www.darwinsys.ru/
* @version $Id: RandomInt.java,v 1.4 2004/03/07 02:51:50 ian Exp $
*/

public class RandomInt {

 public static void main(String[] a) {
   Random r = new Random();
   for (int i=0; i<1000; i++)
     // nextInt(10) goes from 0-9; add 1 for 1-10;
     System.out.println(1+Math.round(r.nextInt(10)));
 }

}



 </source>
   
  
 
  



Generating random numbers

   <source lang="java">
 

/* Java Programming for Engineers Julio Sanchez Maria P. Canton

ISBN: 0849308100 Publisher: CRC Press

  • /

// Java for Engineers //Filename: RandNum //Reference: Chapter 23 //Description: // Generating random numbers

class RandNum {

 public static void main(String[] args) {
   int num;
   int[] dist = new int[10]; // Storage for distribution
   // Generate 10000 random numbers using Math.random()
   for (int x = 0; x < 10000; x++) {
     num = (int) (Math.floor(Math.random() * 10));
     dist[num]++;
   }
   // Display distribution of random integers in the range
   // 0 to 9
   System.out.println("Distribution using Math.random() ");
   for (int k = 0; k < 10; k++)
     System.out.print(k + "\t");
   // Display results
   for (int y = 0; y < 10; y++) {
     System.out.print(dist[y] + "\t");
   }
   System.out.println();
 }

}



 </source>
   
  
 
  



Getting random numbers: nextGaussian

   <source lang="java">
 

import java.util.*; /** Demonstrate the better way of getting random numbers,

* using java.util.Random.next*().
*/

public class Random3 {

 public static void main(String[] argv) {
   // java.util.Random methods are non-static, do need to construct Math
   //+
   Random r = new Random();
   for (int i=0; i<10; i++)
   System.out.println("A gaussian random double is " + r.nextGaussian());
   //-
 }

}



 </source>
   
  
 
  



Math.random

   <source lang="java">
 

/** Demonstrate the easy way of getting random numbers,

* using java.lang.Math.Random().
*/

public class Random1 {

 public static void main(String[] argv) {
   //+
   // java.lang.Math.random() is static, don"t need to construct Math
   System.out.println("A random from java.lang.Math is " + Math.random());
   //-
 }

}



 </source>
   
  
 
  



nextDouble() and nextGaussian() in java.util.Random

   <source lang="java">
 

import java.util.*; import java.io.*; /** Print "n" calls to nextDouble() and nextGaussian() in raw form

* using java.util.Random.next*(); results can be plotted.
*/

public class Random4 {

 public static void main(String[] argv) throws IOException {
   // java.util.Random methods are non-static, do need to construct Math
   Random r = new Random();
   PrintWriter file1 = new PrintWriter(new FileWriter("file1"));
   PrintWriter file2 = new PrintWriter(new FileWriter("file2"));
   for (int i=0; i<10000; i++) {
     file1.println(r.nextDouble());
     file2.println(r.nextGaussian());
   }
   file1.close();
   file2.close();
 }

}


 </source>
   
  
 
  



Next double and next int

   <source lang="java">
 

import java.util.*; /** Demonstrate the better way of getting random numbers,

* using java.util.Random.next*().
*/

public class Random2 {

 public static void main(String[] argv) {
   //+
   // java.util.Random methods are non-static, so need to construct
   Random r = new Random();
   for (int i=0; i<10; i++)
   System.out.println("A double from java.util.Random is " + r.nextDouble());
   for (int i=0; i<10; i++)
   System.out.println("An integer from java.util.Random is " + r.nextInt());
   //-
 }

}



 </source>
   
  
 
  



Operations for random Strings

   <source lang="java">
 

/*

* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
* 
*      http://www.apache.org/licenses/LICENSE-2.0
* 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.util.Random; /**

*

Operations for random Strings.

*

Currently private high surrogate characters are ignored. * These are unicode characters that fall between the values 56192 (db80) * and 56319 (dbff) as we don"t know how to handle them. * High and low surrogates are correctly dealt with - that is if a * high surrogate is randomly chosen, 55296 (d800) to 56191 (db7f) * then it is followed by a low surrogate. If a low surrogate is chosen, * 56320 (dc00) to 57343 (dfff) then it is placed after a randomly * chosen high surrogate.

*
* @author 
* @author Stephen Colebourne
* @author Gary Gregory
* @author Phil Steitz
* @since 1.0
* @version $Id: RandomStringUtils.java 471626 2006-11-06 04:02:09Z bayard $
*/

public class RandomStringUtils {

   /**
*

Random object used by random method. This has to be not local * to the random method so as to not return the same value in the * same millisecond.

    */
   private static final Random RANDOM = new Random();
   /**
*

RandomStringUtils instances should NOT be constructed in * standard programming. Instead, the class should be used as * RandomStringUtils.random(5);.

    *
*

This constructor is public to permit tools that require a JavaBean instance * to operate.

    */
   public RandomStringUtils() {
     super();
   }
   // Random
   //-----------------------------------------------------------------------
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of all characters.

    *
    * @param count  the length of random string to create
    * @return the random string
    */
   public static String random(int count) {
       return random(count, false, false);
   }
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of characters whose * ASCII value is between 32 and 126 (inclusive).

    *
    * @param count  the length of random string to create
    * @return the random string
    */
   public static String randomAscii(int count) {
       return random(count, 32, 127, false, false);
   }
   
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of alphabetic * characters.

    *
    * @param count  the length of random string to create
    * @return the random string
    */
   public static String randomAlphabetic(int count) {
       return random(count, true, false);
   }
   
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of alpha-numeric * characters.

    *
    * @param count  the length of random string to create
    * @return the random string
    */
   public static String randomAlphanumeric(int count) {
       return random(count, true, true);
   }
   
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of numeric * characters.

    *
    * @param count  the length of random string to create
    * @return the random string
    */
   public static String randomNumeric(int count) {
       return random(count, false, true);
   }
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of alpha-numeric * characters as indicated by the arguments.

    *
    * @param count  the length of random string to create
    * @param letters  if true, generated string will include
    *  alphabetic characters
    * @param numbers  if true, generated string will include
    *  numeric characters
    * @return the random string
    */
   public static String random(int count, boolean letters, boolean numbers) {
       return random(count, 0, 0, letters, numbers);
   }
   
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of alpha-numeric * characters as indicated by the arguments.

    *
    * @param count  the length of random string to create
    * @param start  the position in set of chars to start at
    * @param end  the position in set of chars to end before
    * @param letters  if true, generated string will include
    *  alphabetic characters
    * @param numbers  if true, generated string will include
    *  numeric characters
    * @return the random string
    */
   public static String random(int count, int start, int end, boolean letters, boolean numbers) {
       return random(count, start, end, letters, numbers, null, RANDOM);
   }
   /**
*

Creates a random string based on a variety of options, using * default source of randomness.

    *
*

This method has exactly the same semantics as * {@link #random(int,int,int,boolean,boolean,char[],Random)}, but * instead of using an externally supplied source of randomness, it uses * the internal static {@link Random} instance.

    *
    * @param count  the length of random string to create
    * @param start  the position in set of chars to start at
    * @param end  the position in set of chars to end before
    * @param letters  only allow letters?
    * @param numbers  only allow numbers?
    * @param chars  the set of chars to choose randoms from.
    *  If null, then it will use the set of all chars.
    * @return the random string
    * @throws ArrayIndexOutOfBoundsException if there are not
    *  (end - start) + 1 characters in the set array.
    */
   public static String random(int count, int start, int end, boolean letters, boolean numbers, char[] chars) {
       return random(count, start, end, letters, numbers, chars, RANDOM);
   }
   /**
*

Creates a random string based on a variety of options, using * supplied source of randomness.

    *
*

If start and end are both 0, start and end are set * to " " and "z", the ASCII printable * characters, will be used, unless letters and numbers are both * false, in which case, start and end are set to * 0 and Integer.MAX_VALUE. * * <p>If set is not null, characters between start and * end are chosen.

    *
*

This method accepts a user-supplied {@link Random} * instance to use as a source of randomness. By seeding a single * {@link Random} instance with a fixed seed and using it for each call, * the same random sequence of strings can be generated repeatedly * and predictably.

    *
    * @param count  the length of random string to create
    * @param start  the position in set of chars to start at
    * @param end  the position in set of chars to end before
    * @param letters  only allow letters?
    * @param numbers  only allow numbers?
    * @param chars  the set of chars to choose randoms from.
    *  If null, then it will use the set of all chars.
    * @param random  a source of randomness.
    * @return the random string
    * @throws ArrayIndexOutOfBoundsException if there are not
    *  (end - start) + 1 characters in the set array.
    * @throws IllegalArgumentException if count < 0.
    * @since 2.0
    */
   public static String random(int count, int start, int end, boolean letters, boolean numbers,
                               char[] chars, Random random) {
       if (count == 0) {
           return "";
       } else if (count < 0) {
           throw new IllegalArgumentException("Requested random string length " + count + " is less than 0.");
       }
       if ((start == 0) && (end == 0)) {
           end = "z" + 1;
           start = " ";
           if (!letters && !numbers) {
               start = 0;
               end = Integer.MAX_VALUE;
           }
       }
       char[] buffer = new char[count];
       int gap = end - start;
       while (count-- != 0) {
           char ch;
           if (chars == null) {
               ch = (char) (random.nextInt(gap) + start);
           } else {
               ch = chars[random.nextInt(gap) + start];
           }
           if ((letters && Character.isLetter(ch))
               || (numbers && Character.isDigit(ch))
               || (!letters && !numbers)) 
           {
               if(ch >= 56320 && ch <= 57343) {
                   if(count == 0) {
                       count++;
                   } else {
                       // low surrogate, insert high surrogate after putting it in
                       buffer[count] = ch;
                       count--;
                       buffer[count] = (char) (55296 + random.nextInt(128));
                   }
               } else if(ch >= 55296 && ch <= 56191) {
                   if(count == 0) {
                       count++;
                   } else {
                       // high surrogate, insert low surrogate before putting it in
                       buffer[count] = (char) (56320 + random.nextInt(128));
                       count--;
                       buffer[count] = ch;
                   }
               } else if(ch >= 56192 && ch <= 56319) {
                   // private high surrogate, no effing clue, so skip it
                   count++;
               } else {
                   buffer[count] = ch;
               }
           } else {
               count++;
           }
       }
       return new String(buffer);
   }
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of characters * specified.

    *
    * @param count  the length of random string to create
    * @param chars  the String containing the set of characters to use,
    *  may be null
    * @return the random string
    * @throws IllegalArgumentException if count < 0.
    */
   public static String random(int count, String chars) {
       if (chars == null) {
           return random(count, 0, 0, false, false, null, RANDOM);
       }
       return random(count, chars.toCharArray());
   }
   /**
*

Creates a random string whose length is the number of characters * specified.

    *
*

Characters will be chosen from the set of characters specified.

    *
    * @param count  the length of random string to create
    * @param chars  the character array containing the set of characters to use,
    *  may be null
    * @return the random string
    * @throws IllegalArgumentException if count < 0.
    */
   public static String random(int count, char[] chars) {
       if (chars == null) {
           return random(count, 0, 0, false, false, null, RANDOM);
       }
       return random(count, 0, chars.length, false, false, chars, RANDOM);
   }
   

}


 </source>
   
  
 
  



Random boolean

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   boolean b = rand.nextBoolean();
   long l = rand.nextLong();
   float f = rand.nextFloat(); // 0.0 <= f < 1.0
   double d = rand.nextDouble(); // 0.0 <= d < 1.0
 }

}


 </source>
   
  
 
  



Random bytes

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   byte[] bytes = new byte[5];
   rand.nextBytes(bytes);
 }

}


 </source>
   
  
 
  



Random double type number

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   boolean b = rand.nextBoolean();
   long l = rand.nextLong();
   float f = rand.nextFloat(); // 0.0 <= f < 1.0
   double d = rand.nextDouble(); // 0.0 <= d < 1.0
 }

}


 </source>
   
  
 
  



Random float type number

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   boolean b = rand.nextBoolean();
   long l = rand.nextLong();
   float f = rand.nextFloat(); // 0.0 <= f < 1.0
   double d = rand.nextDouble(); // 0.0 <= d < 1.0
 }

}


 </source>
   
  
 
  



Random integers that range from from 0 to n

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   int n = 10;
   int i = rand.nextInt(n + 1);
   System.out.println(i);
 }

}


 </source>
   
  
 
  



Randomizer

   <source lang="java">
 

/*

* Copyright (c) 2000 David Flanagan.  All rights reserved.
* This code is from the book Java Examples in a Nutshell, 2nd Edition.
* It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
* You may study, use, and modify it for any non-commercial purpose.
* You may distribute it non-commercially as long as you retain this notice.
* For a commercial use license, or to purchase the book (recommended),
* visit http://www.davidflanagan.ru/javaexamples2.
*/

/**

* This class defines methods for computing pseudo-random numbers, and defines
* the state variable that needs to be maintained for use by those methods.
*/

public class Randomizer {

 // Carefully chosen constants from the book "Numerical Recipes in C".
 // All "static final" fields are constants.
 static final int m = 233280;
 static final int a = 9301;
 static final int c = 49297;
 // The state variable maintained by each Randomizer instance
 int seed = 1;
 /**
  * The constructor for the Randomizer() class. It must be passed some
  * arbitrary initial value or "seed" for its pseudo-randomness.
  */
 public Randomizer(int seed) {
   this.seed = seed;
 }
 /**
  * This method computes a pseudo-random number between 0 and 1 using a very
  * simple algorithm. Math.random() and java.util.Random are actually a lot
  * better at computing randomness.
  */
 public float randomFloat() {
   seed = (seed * a + c) % m;
   return (float) Math.abs((float) seed / (float) m);
 }
 /**
  * This method computes a pseudo-random integer between 0 and specified
  * maximum. It uses randomFloat() above.
  */
 public int randomInt(int max) {
   return Math.round(max * randomFloat());
 }
 /**
  * This nested class is a simple test program: it prints 10 random ints.
  * Note how the Randomizer object is seeded using the current time.
  */
 public static void main(String[] args) {
     Randomizer r = new Randomizer((int) new java.util.Date().getTime());
     for (int i = 0; i < 10; i++)
       System.out.println(r.randomInt(100));
 }

}


 </source>
   
  
 
  



Random long type number

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) throws Exception {
   Random rand = new Random();
   boolean b = rand.nextBoolean();
   long l = rand.nextLong();
   float f = rand.nextFloat(); // 0.0 <= f < 1.0
   double d = rand.nextDouble(); // 0.0 <= d < 1.0
 }

}


 </source>
   
  
 
  



Random.nextInt(n) returns a distributed int value between 0 (inclusive) and n (exclusive).

   <source lang="java">
 

// random number between 0 AND 10 import java.util.Random; public class Main {

 public static void main(String[] argv) {
   Random r = new Random();
   int randint = r.nextInt(10);
   System.out.println(randint);
 }

}


 </source>
   
  
 
  



Random number between 0 AND 10

   <source lang="java">
 

import java.util.Random; public class Main {

 public static void main(String[] argv) {
   Random r = new Random();
   int randint = Math.abs(r.nextInt()) % 11;
   System.out.println(randint);
 }

}


 </source>
   
  
 
  



Random numbers between 1 and 100

   <source lang="java">
 

public class Main {

 public static void main(String[] args) {
   for(int i=0; i < 5 ; i++){
     System.out.println("Random Number ["+ (i+1) + "] : " + (int)(Math.random()*100));
   }
 }

}


 </source>
   
  
 
  



Round Java float and double numbers using Math.round

   <source lang="java">
 

public class Main {

 public static void main(String[] args) {
   System.out.println(Math.round(10f));
   System.out.println(Math.round(2.5f));
   System.out.println(Math.round(-1.4f));
   System.out.println(Math.round(-2.5f));
 }

} /* 10 3 -1 -2

  • /


 </source>