Operator Perbandingan dan Logika pada Java
Halo sobat IHY!, kali ini saya akan membahas tentang operator perbandingan dan logika pada java. Sebelumnya kita sudah membahas tentang operator aritmetika pada java, yang digunakan untuk operasi matematika, nah sekarang operator perbandingan, Apa itu operator perbandingan?.
Operator Perbandingan
Operator perbandingan adalah operator yang digunakan operasi perbandingan, hasilnya hanya ada 2 yaitu true (jika logika benar) dan false (jika logika salah), nah masih ingat kan tentang tipe data pada java?, nah hasil dari perbandingan ini dapat kita simpan dalam variabel bertipe data boolean.
Berikut ini adalah operator perbandingan yang sering digunakan.
| Operator | Arti | Contoh |
|---|---|---|
| == | Sama dengan |
boolean hasil = 140 == 140;boolean hasil = 123 == 928;
|
| != | Tidak Sama dengan |
boolean hasil = 138 != 198;boolean hasil = 120 != 120;
|
| > | Lebih Dari |
boolean hasil = 273 > 926;boolean hasil = 873 > 882;
|
| >= | Lebih Dari atau sama dengan |
boolean hasil = 287 >= 38;boolean hasil = 236 >= 236;
|
| < | Kurang dari |
boolean hasil = 276 < 398;boolean hasil = 487 < 213
|
| <= | Kurang dari atau sama dengan |
boolean hasil = 288 <= 828;boolean hasil = 392 <= 392;
|
Ya seperti biasa, saya akan sedikit membagi pemahaman dan contoh tentang operator operator tersebut.
Sama dengan (==)
Operator ini digunakan untuk membandingkan dua nilai, mengembalikan nilai true, jika kedua nilai tersebut sama, dan mengembalikan nilai false jika nilainya berbeda, contoh penggunaannya sebagai berikut,
class OperatorPerbandingan { public static void main(String[] args) { boolean hasil1 = 127 == 128; // nilainya false karena 127 tidak sama dengan 128 boolean hasil2 = 263 == 263; // hasilnya true karena pembandingnya bernilai sama boolean hasil3 = (262 + 28) == (248 + 652); boolean hasil4 = (270 / 9) == (300 / 3); System.out.println("Hasil1: "+hasil1); System.out.println("Hasil2: "+hasil2); System.out.println("Hasil3: "+hasil3); System.out.println("Hasil4: "+hasil4); } }
Tidak sama dengan (!=)
Operator ini merupakan kebalikan dari operator sama dengan (==), mengembalikan nilai false, jika kedua nilai tersebut sama, dan mengembalikan nilai true jika nilainya berbeda. Contoh penggunaannya sebagai berikut,
class OperatorPerbandingan { public static void main(String[] args) { boolean hasil1 = 188 != 291; // hasilnya true karena 188 tidak sama dengan 291 boolean hasil2 = 133 != 133; // hasilnya false karena dua pembandingnya nilainya sama boolean hasil3 = (120 / 3) != (18 + 22); boolean hasil4 = (80 / 2) != (3 * 5); System.out.println("Hasil1: "+hasil1); System.out.println("Hasil2: "+hasil2); System.out.println("Hasil3: "+hasil3); System.out.println("Hasil4: "+hasil4); } }
Lebih dari (>)
Operator ini digunakan untuk membandingkan dua nilai. Bila nilai kiri operator lebih besar dari nilai kanan operator, maka akan mengembalikan nilai true, jika kurang dari atau sama dengan, maka akan mengembalikan nilai false. Contohnya sebagai berikut,
class OperatorPerbandingan { public static void main(String[] args) { boolean hasil1 = 276 > 138; // hasilnya true, tahu kan kenapa hehe... boolean hasil2 = 72 > 184; // hasilnya false boolean hasil3 = (57 + 43) > (20 + 17); boolean hasil4 = (18 + 12) > (62 + 28); System.out.println("Hasil1: "+hasil1); System.out.println("Hasil2: "+hasil2); System.out.println("Hasil3: "+hasil3); System.out.println("Hasil4: "+hasil4); } }
Lebih dari atau sama dengan (>=)
Hampir sama fungsinya dengan operator lebih dari (>) tapi, jika dua nilai yang dibandingkan sama maka akan mengembalikan nilai true. Contohnya sebagai berikut,
class OperatorPerbandingan { public static void main(String[] args) { boolean hasil1 = 193 > 193; // hasilnya false, karena 193 tidak kurang dari 193 boolean hasil2 = 176 >= 176; // hasilnya true, karena walaupun 176 tidak lebih dari 176, tapi nilainya sama boolean hasil3 = (47 + 43) > (20 + 70); boolean hasil4 = (18 + 12) >= (13 + 17); System.out.println("Hasil1: "+hasil1); System.out.println("Hasil2: "+hasil2); System.out.println("Hasil3: "+hasil3); System.out.println("Hasil4: "+hasil4); } }
Kurang dari (<)
Operator merupakan kebalikan dari operator lebih dari (>). Bila nilai kiri operator lebih kecil dari nilai kanan operator, maka akan mengembalikan nilai true, jika lebih dari atau sama dengan, maka akan mengembalikan nilai false. Contohnya sebagai berikut,
class OperatorPerbandingan { public static void main(String[] args) { boolean hasil1 = 183 < 239; // hasilnya true boolean hasil2 = 379 < 269; // hasilnya false boolean hasil3 = (100 / 5) < (100 - 30); boolean hasil4 = (50 / 2) < (20 / 5); System.out.println("Hasil1: "+hasil1); System.out.println("Hasil2: "+hasil2); System.out.println("Hasil3: "+hasil3); System.out.println("Hasil4: "+hasil4); } }
Kurang dari atau sama dengan (<=)
Hampir sama fungsinya dengan operator kurang dari (<) tapi, jika dua nilai yang dibandingkan sama maka akan mengembalikan nilai true. Contohnya sebagai berikut,
class OperatorPerbandingan { public static void main(String[] args) { boolean hasil1 = 18 < 18; // hasilnya false boolean hasil2 = 10 <= 10; // hasilnya true boolean hasil3 = (100 / 5) <= (100 - 30); boolean hasil4 = (50 / 2) < (20 / 5); System.out.println("Hasil1: "+hasil1); System.out.println("Hasil2: "+hasil2); System.out.println("Hasil3: "+hasil3); System.out.println("Hasil4: "+hasil4); } }
Operator Logika
Selanjutnya adalah tentang operator Logika. Operator Logika adalah operator yang digunakan untuk operasi logika, biasanya untuk membandingkan 2 atau lebih kondisi. Berikut beberapa operator logika yang sering digunakan,
| Operator | Arti | Contoh |
|---|---|---|
| && | Logika AND |
hasil = (10 > 72) && (19 < 90);hasil = (38 == 38) && (10 > 7);
|
| || | Logika OR |
hasil = (10 < 72) || (81 > 70);hasil = (35 < 38) || (80 > 78);
|
| ! | Logika NOT |
hasil = !(10 > 5);hasil = !(899 < 29);
|
Berikut saya akan sedikit berbagi pemahaman tentang operator Logika.
Operator Logika AND (&&)
Operator logika ini jika digunakan akan menghasilkan nilai true jika semua kondisi yang terlibat juga bernilai true, tapi jika ada satu atau lebih kondisi yang false, maka akan menghasilkan nilai false. Contohnya sebagai berikut,
class OperatorLogika { public static void main(String[] args) { // saya pakai variabel, biar gampang hehe... int a = 20; int b = 15; int c = 10; boolean hasil1 = (a < c) && (c < b); boolean hasil2 = (b < a) && (a > b); boolean hasil3 = hasil1 && hasil2; System.out.println("Hasil 1: "+hasil1); System.out.println("Hasil 2: "+hasil2); System.out.println("Hasil 3: "+hasil3); } }
Operator Logika OR (||)
Operator ini akan menghasilkan nilai true jika ada satu atau lebih kondisi yang nilainya true, dan akan menghasilkan nilai false jika semua kondisi yang terlibat bernilai false. Contohnya sebagai berikut,
class OperatorLogika { public static void main(String[] args) { int a = 20; int b = 20; int c = 15; boolean hasil1 = (a < c) || (c < b); boolean hasil2 = (b < a) || (a == b); boolean hasil3 = hasil1 || hasil2; System.out.println("Hasil 1: "+hasil1); System.out.println("Hasil 2: "+hasil2); System.out.println("Hasil 3: "+hasil3); } }
Operator Logika NOT (!)
Operator ini jika digunakan akan membalikan hasil kondisinya, misal jika suatu kondisi bernilai true, tapi 'ketempelan' operator NOT maka hasilnya akan false, contohnya adalah sebagai berikut, kita pakai kode yang tadi (untuk contoh OR) dengan sedikit modifikasi,
class OperatorLogika { public static void main(String[] args) { int a = 20; int b = 20; int c = 15; boolean hasil1 = (a < c) || (c < b); boolean hasil2 = (b < a) || (a == b); boolean hasil3 = hasil1 || hasil2; System.out.println("Tanpa NOT"); System.out.println("Hasil 1: "+hasil1); System.out.println("Hasil 2: "+hasil2); System.out.println("Hasil 3: "+hasil3); System.out.println("Dengan NOT"); System.out.println("Hasil 1: "+!hasil1); System.out.println("Hasil 2: "+!hasil2); System.out.println("Hasil 3: "+!hasil3); } }
Tambahan: Operator Bitwise
Operator bitwise erat kaitannya dengan ekspresi biner dan aljabar boolean. Operator bitwise ada 4 yaitu Bitwise AND (&) Bitwise OR (|) Bitwise XOR (^) dan Bitwise NOT (~). Bagaimana itu?, langsung saya kasih contoh aja ya,
class OperatorPerbandingan { public static void main(String[] args) { int a = 10; int b = 20; System.out.println("a = "+a); System.out.println("b = "+b+"\n"); // contoh bitwise AND System.out.println("a & b = "+(a & b)); // output: 0 // contoh bitwise OR System.out.println("a | b = "+(a | b)); // output: 30 // contoh bitwise XOR System.out.println("a ^ b = "+(a ^ b)); // output: 30 // contoh bitwise NOT System.out.println("~a = "+ ~a); // output: -11 System.out.println("~b = "+ ~b); // output: -21 } }
Penjelasan:
Pertama-tama, kita ubah dulu angka-angka nya ke bentuk biner dengan 32 digit, karena ukuran tipe data int adalah 32 bit.
Disini 1 kita artikan sebagai true, dan 0 kita artikan sebagai false.
Oke, sekarang saya akan jabarkan, bagaimana outputnya bisa sekian.
Bitwise AND (a & b = 0)
Angka angka biner yang 'terlibat' di logika AND memiliki rumus dan persyaratan berikut,
Maka dari itu
00000000000000000000000000001010 &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 00000000000000000000000000010100 -------------------------------- 00000000000000000000000000000000 = 0.
Bitwise OR (a | b = 30)
Maka dari itu
00000000000000000000000000001010 |||||||||||||||||||||||||||||||| 00000000000000000000000000010100 -------------------------------- 00000000000000000000000000011110 = 30.
Bitwise XOR (a ^ b = 30)
Tanda seru (!) maksudnya kebalikan. Contoh pengerjaanya adalah sebagai berikut,
Misal X = 1 dan Y = 1.
Nah, sesuai kan sama tabel di gambar.
Oke jadi kenapa a ^ b itu 30 karena,
00000000000000000000000000001010 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 00000000000000000000000000010100 -------------------------------- 00000000000000000000000000011110 = 30.
Nah kan, silahkan kalau tidak percaya cocokan dengan tabel di atas.
Bitwise NOT (~a = -11; ~b = -21)
Jadi kenapa ~a = -11, itu karena,
00000000000000000000000000001010 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11111111111111111111111111110101 = -11.
dan, ~b = -21, karena,
00000000000000000000000000010100 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11111111111111111111111111101011 = -21.
Ya intinya tinggal diganti saja 0 dengan 1 dan 1 dengan 0.
Itu dia, sedikit tentang operator perbandingan dan operator Logika, juga dengan Operator Bitwise pada Java, jika ada kritik, saran, atau pertanyaan silahkan gunakan kolom komentar dibawah, Terima Kasih.
Komentar
Posting Komentar