Gyakorlati alapok
Tömb feltöltése véletlenszámokkal
Majdnem az összes eddigi, általunk gyártott algoritmus jól szabályozott, valójában szekvenciális bemeneti adatokkal dolgozott, például növekvő számsor 1 és 50 között:
1 2 3 4 5 ... 50
Továbbiakban azonban néha előnyösebb volna véletlenszámokat felhasználni bemeneti adatokként.
A Java-nyelv előre gyártott függvények segítségével lehetővé teszi sokféle véletlenszám generálását. Ehhez először egy illetékes függvénycsomagot kell elérnünk és beillesztenünk a projektbe, azaz importálnunk kell. Erre többféle lehetőségünk is van, kezdjük a Math csomagban elérhető random() függvénnyel (import java.math.*;):
import java.math.*;
public class Main {
public static void main(String[] args) {
double tomb[] = new double [5];
for (int i = 0; i < tomb.length; i++){
tomb[i] = Math.random();
System.out.println(tomb[i] + " ");
}
}
}
Végeredmény (például):
0.33727570895366077
0.812815435012241
0.9223552397498324
0.7586426228742107
0.25801830843964624
Láthatjuk, hogy nem elég véletlenszámokat generálni, azokat azonnal el is kell tárolnunk. Ehhez a legegyszerűbb tárolóobjektum a tömb (double tomb[] = new double [5];), amelynek típusát a korrekt tároláshoz szintén double-ra kell beállítanunk, hiszen a random() függvény double típust ad vissza kimeneti típusként.
Célunkat elértük, de azért furcsa véletlenszámokat kaptunk: double a típusuk, azaz földi giliszta hosszúságú tizedes törtek 0 és 1 között. Nem lehetetlen, de nehéz lesz így őket felhasználni, mert nekünk elsősorban 0 és 100 közötti egész számok kellenének. Ehhez kissé trükköznünk kell a fenti kódban:
import java.math.*;
public class Main {
public static void main(String[] args) {
int tomb[] = new int [10];
int veletlenSzam;
for (int i = 0; i < tomb.length;
i++){
veletlenSzam
= (int)(Math.random() * 100);
tomb[i] =
veletlenSzam;
System.out.print(tomb[i] + " ");
}
}
}
Végeredmény (például):
72 72 32 87 93 51 19 52 0 62
Ha a véletlenszámot 100-zal megszorozzuk (Math.random() * 100), akkor már jó a számtartomány (1 és 100 között), de még mindig double típusú, ezért kasztolnunk kell int típusra ((int)(Math.random() * 10)), bár ekkor még nem zártuk ki a 0 lehetőségét:
import java.math.*;
public class Main {
public static void main(String[] args) {
int tomb[] = new int [10];
int veletlenSzam;
for (int i = 0; i < tomb.length; i++){
veletlenSzam = (int)(Math.random() *
100);
if(veletlenSzam != 0){
tomb[i] = veletlenSzam;
System.out.print(tomb[i] + " ");
}
else
continue;
}
}
}
Végeredmény (például):
72 87 83 72 3 18 87 42 61 42
A végeredmény már semmiképpen sem fog tartalmazni 0 számot a feltételmegadás szűrése miatt (if(veletlenSzam != 0)).
A fenti, 0-t kizáró véletlenkód egy másik megfogalmazásban, hátultesztelő ciklussal:
import java.math.*;
public class Main {
public static void main(String[] args) {
int tomb[] = new int [10];
int veletlenSzam;
for (int i = 0; i < tomb.length; i++){
do{
veletlenSzam = (int)(Math.random() * 100);
}while(veletlenSzam == 0);
tomb[i] = veletlenSzam;
System.out.print(tomb[i] + " ");
}
}
}
Végeredmény (például):
53 54 70 54 57 40 14 5 71 51
A Java-csomagok között egy másik véletlengenerátort is találunk, ez a java.util csomagban érhető el (import java.util.Random;).
import java.util.Random;
public class Main {
public static void main(String[] args) {
int tomb[] = new int [10];
Random random = new Random();
for (int i = 0; i < tomb.length; i++){
tomb[i] = random.nextInt(100) + 1;
System.out.print(tomb[i] + " ");
}
}
}
Végeredmény (például):
16 74 54 92 32 14 10 7 91 77
A véletlenszám generáló objektumot létre kell hoznunk (Random random = new Random();), ezután pedig -mivel int típusú, egész számú számtartományt keresünk-, a nextInt() metódust kell választanunk. A számtartomány beállítása kissé furcsa: 1 és 100 közötti tartományt így kell beállítanunk:
random.nextInt(100) + 1
Ekkor +1 az alsóhatár, 100 pedig az alsóhatárhoz hozzáadott számmennyiség. Ha például -50 és +50 között szeretnénk véletlenszámokat generálni, a következő beállítást kell megtennünk:
random.nextInt(100) - 50
(Alsóhatár -50 és onnantól számítva 100, azaz +50-ig)
import java.util.Random;
public class Main {
public static void main(String[] args) {
int tomb[] = new int [10];
Random random = new Random();
for (int i = 0; i < tomb.length; i++){
tomb[i] = random.nextInt(100) - 50;
System.out.print(tomb[i] + " ");
}
}
}
Végeredmény (például):
48 37 18 32 -23 -3 23 11 32 47
Ha nem állítjuk be a számtartományt, azaz nem szűrjük a feltételeket, a nextInt() metódus teljesen "elszáll" a véletlenszám generálásában (ezzel valójában semmi gond, teszi a függvény a dolgát, bár gyakorláshoz nekünk azért előnyösebb a szabályozott véletlenszám-generálás, mondjuk 1 és 100 között):
import java.util.Random;
public class Main {
public static void main(String[] args) {
int tomb[] = new int [10];
Random random = new Random();
for (int i = 0; i < tomb.length; i++){
tomb[i] = random.nextInt();
System.out.print(tomb[i] + " ");
}
}
}
Végeredmény (például):
-1888781857
117423556
1858211410
-2028317762
-1172308622
1501841189
-706892826
2125903736
1919156170
554955556
Természetesen számos további, egyre szofisztikáltabb működésű függvény áll rendelkezésünkre. Alábbival például double tipusú véletlenszámokat generáltunk (random.nextDouble()):
import java.util.Random;
public class Main {
public static void main(String[] args) {
double tomb[] = new double [10];
Random random = new Random();
for (int i = 0; i < tomb.length; i++){
tomb[i] = random.nextDouble();
System.out.println(tomb[i] + " ");
}
}
}
Végeredmény (például):
0.25706525949960035
0.17807994221233625
0.1319530225420278
0.36287750826757015
0.6555986977039981
0.21924784511050854
0.08524482861948779
0.2560909534007454
0.2460006155046608
0.8710926525988189
Pénzes László