Bilangan Random dengan Java

Salah satu penerapan dari Mata Kuliah Model dan Simulasi adalah Penerapan Model Matematika, contohnya membuat algoritma untuk memecahkan masalah dan kemudian menuangkannya dalam suatu bahasa pemrograman tertentu, sehingga masalah pun terpecahkan, Contohnya seperti berikut yaitu permasalahan untuk memunculkan bilangan random atau bilangan acak yang secara otomatis muncul atau ditampilkan oleh program atau suatu model matematika yang telah di tuangkan ke dalam koding pemrograman.

Apa Fungsinya bilangan ramdom??.. jawabnya mudah sekali, Anda tahu Pulsa Fisik atau Voucher Pulsa?.. kode yang Anda gosok dalam voucher tersebut merupakan implementasi dari bilangan random, sehingga tidak ada duplikat Voucher Code sehingga Operator tidak dapat mengalami kerugian akibat dari suatu pihak yang menebak-nebak kode voucher... okeh...

1. Yang paling sederhana adalah menggunakan math.random dari java :

A. Menampilkan Bilangan Random

import java.math.*;

package pelajaranjava;
import java.math.*;

public class Main {


public static void main(String[] args) {

double angka = Math.random()*11;

System.out.println(Math.ceil(angka));


}

}

Penjelasan Skrip


Math.random()*11; =Menghasilkan nilai random dengan nilai yang paling terbesar adalah 10


Math.ceil(angka); =Menghasilkan bilangan bulat terkecil dari variabel angka yang bertipe Double yang menampung nilai random


double angka = Math.random()*11; =Menghasilkan nilai random dengan nilai yang paling terbesar adalah 10 kemudian ditampung oleh variabel angka dengan tipe double


System.out.println(Math.ceil(angka)); = Menampilkan bilangan bulat terkecil dari variabel angka

B. Mencari Nilai Maksimum dari Bilangan Random 1-100

import javax.swing.*;
public class Maksimum
{
public static void main (String[ ] args)
{
int[ ] nilai = new int [10];
int nilaiMaks;


//Memperoleh bilangan random

for (int i = 0; i < 10; i++) nilai[i] = (int) (100 * Math.random()); // Mencari maksimum nilaiMaks = nilai[0];
for (int i = 0; i nilaiMaks) nilaiMaks = nilai[i]; }
System.out.println(“Nilai maksimum = ” + nilaiMaks); } }


2. Untuk membuat/menampilkan bilangan random dengan java adalah dengan menggunakan class java.util.Random Pertama Kita buat dulu Kelas untuk meng-generate bilangan random nya:

1. import java.util.*;
2.
3. public class RandomGenerator {
4. private static Random random = new Random();
5. 6. public static String generateActivationCode(int length) {
7. String code = new String("");
8. for (int i = 0; i < length; i++) {
9. code += (char) (random.nextInt(10) + '0');
10. }
11. return code;
12. }
13. }


Setelah itu Kita Bbuat Main Class untuk memanggil class diatas :

1. public class TestRandom {
2. public static void main(String[] args) {
3. RandomGenerator random = new RandomGenerator();
4. for (int i = 0; i < 10; i++) {
5. System.out.println("" + random.generateActivationCode(6) + "");
6. }
7. }
8. }
   

Contoh di atas adalah untuk men-generate bilangan random 6 digit sebanyak 10 bilangan. Untuk men-generate bilangan random dengan jumlah digit tertentu dan dalam jumlah tertentu kita tinggal mengubah parameter dan jumlah pengulangannya.

Hasilnya :


3. Berikut ada 1 contoh lagi penggunaan dari class Random

1. import java.util.Random;
3. public class ContohRandom {
4. public static void main(String[] args) {
5. Random objRandom = new Random();
6. //Cetak 10 pasangan angka random Float dan Gaussian
7. for (int i = 0; i < 10; i++) {
8. System.out.println("Random Float = " + objRandom.nextFloat());
9. System.out.println("Random Gaussian = " + objRandom.nextGaussian());
10. }
11. }
12. }
    

Hasilnya sebagai beriku : (tiap kali eksekusi maka berubah-ubah hasilnya - random)

1. Random Float = 0.46137494
2. Random Gaussian = 0.19129395789596115
3. Random Float = 0.79352367
4. Random Gaussian = 0.2553390959612054
5. Random Float = 0.6459138
6. Random Gaussian = -1.8578221330769598
7. Random Float = 0.7674308
8. Random Gaussian = 0.13942810028379926
9. Random Float = 0.39630258
10. Random Gaussian = -1.8724192706456557
11. Random Float = 0.95785886
12. Random Gaussian = 0.8083143472565751
13. Random Float = 0.6814118
14. Random Gaussian = -1.4436771221509253
15. Random Float = 0.17211175
16. Random Gaussian = -1.4963856699604225
17. Random Float = 0.0025584698
18. Random Gaussian = 0.7271306516826876
19. Random Float = 0.28490603
20. Random Gaussian = -0.07706790659581358
    

4. Saya juga menemukan tutorial penerapan dari random number untuk implementasi pada keamanan password ataupun Kriptografi, berikut contoh nya, menggunakan SecureRandom :

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

public class SecureRandomNumber {

private static final String SHA1_PRNG = "SHA1PRNG";

// Default here is 64-bits of random goodness.
private static final int DEFAULT_RANDOM_SIZE = 64;

private static final char HEX_DIGIT [] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};

// This ins't thread safe but we probably don't really care
// since all we're doing is reading a bunch of random numbers
// out of the generator.
private static final SecureRandom sRandom__;
static {
try {
sRandom__ = SecureRandom.getInstance( SHA1_PRNG );
} catch ( NoSuchAlgorithmException e ) {
throw new Error(e);
}
}

/**
* Get the number of next random bits in this SecureRandom
* generators' sequence.
* @param size how many random bits you want
* @return
* @throws IllegalArgumentException if the arg isn't divisible by eight
*/
public static byte [] getNextSecureRandom ( int bits ) {

// Make sure the number of bits we're asking for is at least
// divisible by 8.
if ( (bits % 8) != 0 ) {
throw new IllegalArgumentException("Size is not divisible " +
"by 8!");
}

// Usually 64-bits of randomness, 8 bytes
final byte [] bytes = new byte[ bits / 8 ];

// Get the next 64 random bits. Forces SecureRandom
// to seed itself before returning the bytes.
sRandom__.nextBytes(bytes);

return bytes;

}

/**
* Convert a byte array into its hex String
* equivalent.
* @param bytes
* @return
*/
public static String toHex ( byte [] bytes ) {

if ( bytes == null ) {
return null;
}

StringBuilder buffer = new StringBuilder(bytes.length*2);
for ( byte thisByte : bytes ) {
buffer.append(byteToHex(thisByte));
}

return buffer.toString();

}

/**
* Convert a single byte into its hex String
* equivalent.
* @param b
* @return
*/
private static String byteToHex ( byte b ) {
char [] array = { HEX_DIGIT[(b >> 4) & 0x0f],
HEX_DIGIT[b & 0x0f] };
return new String(array);
}

/**
* An example showing how to use SecureRandomNumber.
* @param args
*/
public static void main ( String [] args ) {

for ( int i = 0; i < randbytes =" SecureRandomNumber.">