Operator dan Ekspresi di Java

Operator adalah simbol yang memberitahu Java untuk melakukan operasi tertentu pada data. Memahami operator adalah fondasi untuk menulis ekspresi yang benar — dari kalkulasi sederhana hingga pengambilan keputusan yang kompleks. Java memiliki sekumpulan operator yang mirip dengan C/C++, dengan beberapa keunikan tersendiri. Mari kita bahas semuanya.

Operator Aritmatika

public class OperatorAritmatika {
    public static void main(String[] args) {
        int a = 10, b = 3;

        System.out.println(a + b);   // Output: 13 (penjumlahan)
        System.out.println(a - b);   // Output: 7  (pengurangan)
        System.out.println(a * b);   // Output: 30 (perkalian)
        System.out.println(a / b);   // Output: 3  (pembagian integer!)
        System.out.println(a % b);   // Output: 1  (modulo/sisa bagi)

        // Pembagian desimal — setidaknya satu harus double
        System.out.println((double) a / b); // Output: 3.3333333333333335
        System.out.println(10.0 / 3);       // Output: 3.3333333333333335
    }
}

Perhatian: 10 / 3 di Java menghasilkan 3 (integer division), bukan 3.33. Ini sumber bug yang sangat umum! Selalu pastikan setidaknya satu operand adalah double jika ingin hasil desimal.

Operator Penugasan

int nilai = 50;

nilai += 20;    // nilai = nilai + 20  → 70
nilai -= 10;    // nilai = nilai - 10  → 60
nilai *= 3;     // nilai = nilai * 3   → 180
nilai /= 4;     // nilai = nilai / 4   → 45
nilai %= 7;     // nilai = nilai % 7   → 3

System.out.println(nilai); // Output: 3

Operator Increment dan Decrement

int x = 5;

System.out.println(x++); // Output: 5 (cetak dulu, lalu x=6)
System.out.println(x);   // Output: 6

System.out.println(++x); // Output: 7 (x jadi 7 dulu, lalu cetak)
System.out.println(x);   // Output: 7

int y = 10;
System.out.println(y--); // Output: 10 (cetak dulu, lalu y=9)
System.out.println(--y); // Output: 8  (y jadi 8 dulu, lalu cetak)

Operator Perbandingan

int a = 10, b = 20;

System.out.println(a == b);  // Output: false
System.out.println(a != b);  // Output: true
System.out.println(a < b);   // Output: true
System.out.println(a > b);   // Output: false
System.out.println(a <= 10); // Output: true
System.out.println(a >= 11); // Output: false

Ingat: Untuk String, selalu gunakan .equals() bukan ==:

String s1 = "java";
String s2 = new String("java");

System.out.println(s1 == s2);        // Output: false (referensi berbeda!)
System.out.println(s1.equals(s2));   // Output: true  (isi sama) ✅
System.out.println(s1.equalsIgnoreCase("JAVA")); // Output: true

Operator Logika

boolean hujan = true;
boolean angin = false;

// AND (&&) — kedua kondisi harus true
System.out.println(hujan && angin);  // Output: false
System.out.println(hujan && true);   // Output: true

// OR (||) — salah satu cukup true
System.out.println(hujan || angin);  // Output: true
System.out.println(false || angin);  // Output: false

// NOT (!)
System.out.println(!hujan); // Output: false

// Short-circuit evaluation
int x = 0;
boolean hasil = (x != 0) && (10 / x > 1); // Bagian kanan tidak dievaluasi
System.out.println(hasil); // Output: false (tidak error meski ada pembagian nol)

Operator Ternary

Ekspresi kondisional ringkas dalam satu baris:

int nilai = 75;
String status = (nilai >= 60) ? "Lulus" : "Tidak Lulus";
System.out.println(status); // Output: Lulus

// Nested ternary
String grade = (nilai >= 90) ? "A" :
               (nilai >= 80) ? "B" :
               (nilai >= 70) ? "C" :
               (nilai >= 60) ? "D" : "E";
System.out.println(grade); // Output: C

// Dalam System.out.println
System.out.println("Status: " + (nilai >= 60 ? "LULUS" : "GAGAL"));
// Output: Status: LULUS

Operator instanceof

Mengecek apakah sebuah objek adalah instance dari class tertentu:

Object obj = "Halo Java";

System.out.println(obj instanceof String);  // Output: true
System.out.println(obj instanceof Integer); // Output: false

// Pattern matching instanceof (Java 16+)
if (obj instanceof String teks) {
    System.out.println("Panjang: " + teks.length());
    // Output: Panjang: 9
}

// Tanpa pattern matching (cara lama)
if (obj instanceof String) {
    String teks = (String) obj; // harus cast manual
    System.out.println(teks.toUpperCase());
}

Operator Bitwise

Bekerja pada level bit — berguna untuk flag, masking, dan optimasi:

int a = 6;  // binary: 0110
int b = 3;  // binary: 0011

System.out.println(a & b);   // Output: 2  (AND:  0010)
System.out.println(a | b);   // Output: 7  (OR:   0111)
System.out.println(a ^ b);   // Output: 5  (XOR:  0101)
System.out.println(~a);      // Output: -7 (NOT)
System.out.println(a << 1);  // Output: 12 (shift kiri: 1100)
System.out.println(a >> 1);  // Output: 3  (shift kanan: 0011)
System.out.println(-8 >>> 1); // Output: 2147483644 (unsigned right shift)

Urutan Prioritas Operator

// Perkalian lebih tinggi dari penjumlahan
int hasil = 2 + 3 * 4;
System.out.println(hasil); // Output: 14 (bukan 20!)

// Gunakan tanda kurung untuk kepastian
int hasil2 = (2 + 3) * 4;
System.out.println(hasil2); // Output: 20

// && lebih tinggi dari ||
boolean cek = true || false && false;
// Diproses: true || (false && false) = true || false = true
System.out.println(cek); // Output: true

// Evaluasi yang lebih jelas dengan tanda kurung
boolean cek2 = (true || false) && false;
System.out.println(cek2); // Output: false

Pertanyaan yang Sering Diajukan

Mengapa == tidak bisa digunakan untuk membandingkan String di Java?

== membandingkan referensi memori (apakah dua variabel menunjuk ke objek yang sama), bukan isi objek. String literal mungkin menghasilkan true karena Java String Pool mengoptimalkan penyimpanan, tapi new String("abc") == new String("abc") selalu false. Gunakan .equals() untuk keamanan dan kejelasan.

Apa itu short-circuit evaluation pada && dan ||?

Pada &&, jika operand kiri false, operand kanan tidak dievaluasi (hasilnya pasti false). Pada ||, jika operand kiri true, operand kanan tidak dievaluasi (hasilnya pasti true). Ini berguna untuk menghindari error seperti null != obj && obj.doSomething() — jika obj null, bagian kanan dilewati.

Apa perbedaan >> dan >>> di Java?

>> adalah arithmetic right shift yang mempertahankan tanda (sign bit) — bilangan negatif tetap negatif. >>> adalah logical/unsigned right shift yang mengisi bit kiri dengan 0, tanpa memperhatikan tanda. Biasanya hanya >> yang digunakan dalam kode biasa; >>> lebih khusus untuk manipulasi bit level rendah.

Kapan menggunakan operator ternary vs if-else?

Gunakan ternary ? : untuk ekspresi sederhana yang menghasilkan satu nilai — terutama dalam inisialisasi variabel atau argumen method. Gunakan if-else untuk kondisi yang membutuhkan banyak baris kode, multiple statement, atau ketika readability lebih penting. Nested ternary harus dihindari karena menyulitkan pembacaan kode.

Kesimpulan

Ringkasan operator Java:

Artikel sebelumnya: Variabel dan Tipe Data di Java — cara menyimpan data di Java.

Langkah selanjutnya: Percabangan dan Perulangan di Java — cara membuat pengambilan keputusan dan iterasi dalam program Java.