Operator Java: Aritmatika, Perbandingan, Logika, dan Penugasan

Apa yang Dilakukan Operator

Operator adalah simbol yang menggabungkan nilai untuk menghitung nilai baru. Kamu sebenarnya sudah memakainya: + menjumlahkan, > membandingkan. Java mengelompokkannya ke dalam beberapa keluarga: aritmatika, perbandingan, logika, penugasan, dan beberapa operator khusus seperti increment dan ternary.

Sebagian besar operator menerima dua nilai (satu sebelum dan satu sesudah simbolnya) lalu menghasilkan sebuah hasil. Kuncinya adalah tahu tipe hasilnya dan urutan penerapannya, karena di situlah pemula sering tersandung.

Operator Aritmatika

Lima operator aritmatika bekerja pada angka: +, -, *, /, dan % (sisa bagi).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (integer division!)
        System.out.println(a % b);   // 2  (the remainder)
    }
}

Operator % menghasilkan sisa setelah pembagian: 17 % 5 hasilnya 2 karena 5 masuk ke 17 sebanyak tiga kali dengan sisa 2. Operator ini alat sehari-hari untuk menguji apakah suatu angka habis dibagi: n % 2 == 0 adalah pengecekan standar "apakah n genap?".

Perhatikan juga bahwa + punya dua tugas: dengan angka, operator ini menjumlahkan, tetapi kalau ada String di salah satu sisinya, operator ini menggabungkan teks.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

Baris pertama dibaca dari kiri ke kanan: "Total: " + 3 sudah menjadi string, jadi 4 ditambahkan sebagai teks. Bungkus perhitungannya dengan tanda kurung kalau kamu ingin perhitungan itu dikerjakan lebih dulu.

Jebakan Pembagian Integer

Inilah kejutan yang paling sering terjadi. Kalau kedua operand / adalah bilangan bulat, Java melakukan pembagian integer dan membuang pecahannya. Hasilnya tidak dibulatkan, melainkan dipotong ke arah nol.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, not 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (one double is enough)
        System.out.println((double) 5 / 2); // 2.5 (cast one operand)
    }
}

Untuk mendapatkan hasil desimal, buat minimal satu operand menjadi double: tulis dengan .0, atau cast salah satu sisi dengan (double). Cast (double)(5 / 2) tidak membantu, karena pembagian integer 5 / 2 sudah terjadi sebelum cast; kamu harus melakukan cast pada operand, bukan pada hasilnya.

Operator Perbandingan

Operator perbandingan mengajukan pertanyaan ya/tidak dan mengembalikan boolean. Ada enam: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

Perhatikan perbedaan antara = (penugasan, "taruh nilai ini di sini") dan == (perbandingan, "apakah keduanya sama?"). Tertukar di antara keduanya adalah bug klasik.

Satu catatan penting: == membandingkan referensi objek, bukan isinya. Untuk string, pakai .equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - different objects
        System.out.println(a.equals(b));   // true  - same text
    }
}

Pakai == untuk tipe primitif seperti int dan boolean, dan .equals() setiap kali kamu membandingkan isi objek seperti string.

Operator Logika

Operator logika menggabungkan nilai boolean: && (dan), || (atau), dan ! (tidak). Dengan operator inilah kamu menyatakan kondisi seperti "cukup umur dan punya tiket".

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& dan || melakukan short-circuit: Java berhenti mengevaluasi begitu jawabannya sudah pasti. Dengan &&, kalau sisi kiri false, sisi kanan tidak pernah diperiksa; dengan ||, kalau sisi kiri true, sisi kanan dilewati. Ini bukan sekadar optimasi, kamu bisa mengandalkannya demi keamanan:

if (text != null && text.length() > 0) { ... }

Kalau text bernilai null, sisi kiri false dan text.length() tidak pernah dipanggil, sehingga NullPointerException terhindari. Kalau urutannya dibalik, program akan crash.

Penugasan dan Increment

= melakukan penugasan, tetapi Java juga punya penugasan gabungan yang menyatukan operasi dengan penugasan: +=, -=, *=, /=, %=. Lalu ++ / -- menambah atau mengurangi satu.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ punya dua bentuk: postfix (count++) mengembalikan nilai lama lalu menambahkan satu; prefix (++count) menambahkan satu dulu lalu mengembalikan nilai baru. Perbedaannya hanya penting kalau kamu memakai hasilnya di ekspresi yang sama:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // prints 5, then x becomes 6
        System.out.println(++x);   // x becomes 7, prints 7
    }
}

Kalau ++ berdiri sendiri di satu baris, postfix dan prefix tidak ada bedanya. Jadi pilih saja yang paling jelas dibaca, dan jangan menjejalkan increment ke dalam ekspresi yang lebih besar.

Operator Ternary

Ternary condition ? a : b adalah if/else versi ringkas yang menghasilkan nilai: kalau kondisinya true, hasilnya a, kalau tidak, hasilnya b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

Operator ini cocok untuk penugasan pilihan-salah-satu yang pendek. Hindari menumpuk ternary di dalam ternary, karena cepat sekali menjadi sulit dibaca, dan if/else biasa jauh lebih jelas.

Prioritas dan Tanda Kurung

Operator diterapkan dalam urutan yang tetap, mirip matematika: *, /, % lebih kuat daripada + dan -, yang lebih kuat daripada perbandingan, yang lebih kuat daripada &&, lalu ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, not 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

Kamu tidak perlu menghafal tabel lengkapnya. Kalau sebuah ekspresi mencampur beberapa keluarga operator atau kamu harus berhenti sejenak untuk memikirkan urutannya, tambahkan tanda kurung. Tanda kurung tidak ada ruginya dan membuat maksudmu jelas bagi pembaca berikutnya.

Berikutnya: Type Casting

Beberapa jebakan di sini, seperti pembagian integer dan mencampur int dengan double, berakar pada tipe. Mengubah satu tipe angka ke tipe lain secara sengaja disebut casting, dan itulah topik halaman berikutnya.