Operátorok
Összehasonlító (relációs) operátorok
Hála a processzor belső architektúrájának, a számítógép nem csak számolni, hanem logikai kapuk segítségével dönteni is képes. A hétköznapi életben nap mint nap nekünk is sokszor kell döntenünk, például: ha esőre áll az idő, viszünk magunkkal esernyőt. Nézzük ezt meg pszeudokód formájában:
if(eso == true){
esernyoCipeles();
}
Máskor úgy kell döntenünk, hogy összehasonlításokat teszünk, például: ha van ebből a barna cipőből az én méretemben, megveszem. Nézzük ezt meg pszeudokód formájában:
if(cipoSzin == barna && cipoMeret == 42){
cipoVasarlas();
}
Az összehasonlító operátorok használatával mindez akár már le is programozható.
A legelső és talán a legfontosabb 2 szimbólum az egyenlőség (==) és a nem-egyenlőség (!=) operátora. Ez hangsúlyozottan nem azonos az értékadás (=) szimbólumával, mert az utóbbi valójában csak egy egyszerű érték-hozzárendelés.
Vegyük észre, hogy az egyenlőség vizsgálata ennél jóval több: mindig azt vizsgálja, hogy a beállított feltétel megfelelő-e. Az alábbi futtatható Java-kódban egy véletlenszám-generátor tölti fel int a változót 1 és 20 közötti integer számokkal. Ha int a változóba 12 kerül, akkor az kiírásra kerül a konzolra. Ennek valószínűsége egyébként 5 %. Az algoritmus legfontosabb része a feltétel beállítása az egyenlőség operátor felhasználásával:
if(a == 12)
import java.util.Random;
public class Main {
public static void main(String[] args) {
Random rnd = new Random();
int a = 0;
a = rnd.nextInt(20) + 1;
if(a == 12){
System.out.println(a);
}
}
}
Végeredmény:
Ha van, akkor 12
Most nézzük meg a nem egyenlő (!=) operátor használatát! Az alábbi algoritmus 10 db véletlenszámból kiválasztja a páratlan számokat és kiírja a konzolra. Az algoritmus legfontosabb része itt is a feltétel beállítása a nem-egyenlőség operátor felhasználásával:
if(a % 2 != 0)
import java.util.Random;
public class Main {
public static void main(String[] args) {
Random rnd = new Random();
int a = 0;
for(int i = 0; i < 10; i++){
a =
rnd.nextInt(20) + 1;
if(a % 2 !=
0){
System.out.println(a);
}
}
}
}
Végeredmény (például):
17
19
1
13
19
15
További összehasonlító operátorok –amint azt az általános iskola alsó tagozatában már megtanultuk-, a nagyobb (>) és a kisebb (<) szimbólum. Ez a Javában a nagyobb vagy egyenlő (>=), illetve a kisebb vagy egyenlő (<=) operátorokkal is kiegészülhet. Nézzünk rájuk 1-1 demonstrációs Java-kódot!
Az alábbi algoritmus 100 db 1 és 100 közötti véletlenszámból kiválasztja az 50 vagy ennél nagyobb számokat:
import java.util.Random;
public class Main {
public static void main(String[] args) {
Random rnd = new Random();
int a = 0;
for(int i = 0; i <= 100; i++){
a =
rnd.nextInt(100) + 0;
if(a >= 50){
System.out.println(a);
}
}
}
}
Végeredmény (például):
98
76
59
89
63
91
51
93
98
91
79
54
97
...
Az alábbi algoritmus 100 db 1 és 100 közötti véletlenszámból kiválasztja a 40 és 50 közé eső számokat:
import java.util.Random;
public class Main {
public static void main(String[] args) {
Random rnd = new Random();
int a = 0;
for(int i = 0; i <= 100; i++){
a =
rnd.nextInt(100) + 0;
if(a < 40 &&
a > 30){
System.out.println(a);
}
}
}
}
Végeredmény (például):
36
38
38
34
37
38
31
34
32
39
39
33
34
31
35
Pénzes László