Class Math Java: pow, sqrt, abs, round, random, dan Lainnya

Kotak Peralatan Berisi Method Static

java.lang.Math adalah class yang penuh dengan fungsi matematika siap pakai: pangkat, akar, nilai absolut, pembulatan, trigonometri, logaritma, dan angka acak. Ada dua hal yang membuatnya mudah dipakai:

• Class ini berada di java.lang, yang otomatis di-import oleh setiap file Java. Tidak ada baris import yang perlu ditulis.
• Setiap method-nya static. Kamu memanggilnya lewat nama class, Math.sqrt(25), dan tidak pernah membuat objek Math. Halaman static member menjelaskan arti static.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));    // 8.0
        System.out.println(Math.sqrt(25));     // 5.0
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.max(4, 9));    // 9
        System.out.println(Math.round(2.6));   // 3
    }
}

Perhatikan bahwa sebagian hasil tercetak dengan .0 dan sebagian lagi tidak. Setiap method Math punya tipe return yang tetap, dan mengetahuinya adalah bagian terbesar dari hal yang perlu dipelajari tentang class ini.

Math.pow: Pangkat

Math.pow(base, exponent) memangkatkan sebuah angka. Method ini menerima dua parameter double dan mengembalikan double, bahkan saat kamu memberinya bilangan bulat:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));     // 8.0
        System.out.println(Math.pow(5, 2));     // 25.0
        System.out.println(Math.pow(2, -1));    // 0.5
        System.out.println(Math.pow(9, 0.5));   // 3.0 (a square root)

        int kilobyte = (int) Math.pow(2, 10);
        System.out.println(kilobyte);           // 1024
    }
}

Untuk menyimpan hasilnya di int, lakukan cast dengan (int). Untuk pangkat bilangan bulat yang kecil, hasil double-nya tepat, jadi cast memberikan jawaban yang benar. Hasil yang besar adalah tempat cast bisa salah: double di atas Integer.MAX_VALUE (2.147.483.647) di-cast menjadi persis Integer.MAX_VALUE, jadi (int) Math.pow(2, 40) menghasilkan 2147483647. Cast ke long untuk pangkat yang lebih besar, dan ingat bahwa di atas 2⁵³, double tidak bisa mewakili setiap bilangan bulat dengan tepat. Halaman type casting membahas apa yang dilakukan cast terhadap sebuah nilai.

Java tidak punya operator pangkat. 2 ^ 3 bisa dikompilasi, tetapi ^ adalah bitwise XOR, dan hasilnya 1, bukan 8. Ini salah satu bug pemula yang paling umum dalam kode matematika Java.

double yang bernilai sepuluh juta atau lebih dicetak dalam notasi ilmiah, yang mengejutkan banyak orang saat pertama kali mencetak pangkat sepuluh:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(10, 6));          // 1000000.0
        System.out.println(Math.pow(10, 7));          // 1.0E7
        System.out.println((long) Math.pow(10, 7));   // 10000000
    }
}

1.0E7 berarti 1.0 × 10⁷. Nilainya sama; hanya bentuk cetakannya yang berubah. Lakukan cast ke long, atau format dengan String.format("%.0f", value), untuk mencetaknya sebagai deretan angka biasa.

Math.sqrt dan Math.cbrt: Akar

Math.sqrt(x) mengembalikan akar kuadrat x sebagai double. Math.cbrt(x) mengembalikan akar pangkat tiga.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.sqrt(16));    // 4.0
        System.out.println(Math.sqrt(2));     // 1.4142135623730951
        System.out.println(Math.cbrt(27));    // 3.0
        System.out.println(Math.sqrt(-4));    // NaN

        double a = 3;
        double b = 4;
        System.out.println(Math.sqrt(a * a + b * b));   // 5.0
        System.out.println(Math.hypot(a, b));           // 5.0
    }
}

Akar kuadrat dari bilangan negatif bukan bilangan real, jadi Math.sqrt(-4) mengembalikan NaN ("not a number"), bukan melempar exception. NaN menular ke semua aritmetika yang disentuhnya, jadi periksa input-nya sebelum menghitung akar kalau nilai negatif mungkin muncul. Math.hypot(a, b) langsung menghitung sqrt(a*a + b*b), cara yang umum untuk mendapatkan jarak antara dua titik.

Math.abs: Nilai Absolut

Math.abs(x) menghilangkan tanda. Berbeda dengan pow dan sqrt, method ini mengembalikan tipe yang sama dengan yang kamu berikan: int untuk int, double untuk double.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.abs(7));       // 7
        System.out.println(Math.abs(-2.5));    // 2.5

        int start = 12;
        int end = 5;
        System.out.println("Distance: " + Math.abs(end - start));   // Distance: 7
    }
}

Penggunaan yang biasa adalah selisih ketika kamu peduli pada besarnya, bukan arahnya, seperti jarak antara dua posisi.

Math.max dan Math.min

Math.max(a, b) mengembalikan nilai yang lebih besar dari dua nilai, dan Math.min(a, b) yang lebih kecil. Keduanya menerima tepat dua argumen. Untuk tiga nilai atau lebih, sarangkan pemanggilannya:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.max(4, 9));      // 9
        System.out.println(Math.min(4, 9));      // 4
        System.out.println(Math.max(3, 7.5));    // 7.5

        int a = 12, b = 45, c = 30;
        System.out.println(Math.max(a, Math.max(b, c)));   // 45

        int score = 130;
        int clamped = Math.max(0, Math.min(score, 100));
        System.out.println(clamped);             // 100
    }
}

Kalau kedua argumen bertipe berbeda, yang lebih sempit diperlebar terlebih dahulu. Math.max(3, 7.5) membandingkan dua nilai double dan mengembalikan double. Contoh terakhir menjepit sebuah nilai ke dalam rentang 0 sampai 100: Math.min membatasinya di 100, Math.max menjaganya agar tidak di bawah 0.

Pembulatan: round, floor, ceil

Java punya tiga method pembulatan, dan ketiganya berbeda dalam arah maupun tipe return:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.round(2.4));    // 2
        System.out.println(Math.round(2.5));    // 3
        System.out.println(Math.round(-2.5));   // -2

        System.out.println(Math.floor(2.7));    // 2.0
        System.out.println(Math.floor(-2.3));   // -3.0

        System.out.println(Math.ceil(2.1));     // 3.0
        System.out.println(Math.ceil(-2.7));    // -2.0

        System.out.println((int) 2.7);          // 2
        System.out.println((int) -2.7);         // -2
    }
}

• Math.round membulatkan ke bilangan bulat terdekat. Nilai yang tepat di tengah dibulatkan ke atas, menuju tak hingga positif, jadi 2.5 menjadi 3 dan -2.5 menjadi -2. Method ini mengembalikan long untuk argumen double (dan int untuk float).
• Math.floor selalu membulatkan ke bawah, menuju tak hingga negatif, dan mengembalikan double.
• Math.ceil selalu membulatkan ke atas, menuju tak hingga positif, dan mengembalikan double.
• Cast (int) sama sekali bukan pembulatan: ia membuang bagian pecahannya, yang menggeser bilangan positif ke bawah dan bilangan negatif ke atas.

Karena Math.round(double) mengembalikan long, menyimpannya di int tidak bisa dikompilasi tanpa cast:

int n = Math.round(2.6);          // error: incompatible types: possible lossy conversion from long to int
int m = (int) Math.round(2.6);    // OK, m is 3
long k = Math.round(2.6);         // OK

Untuk membulatkan ke sejumlah angka di belakang koma, perbesar nilainya, bulatkan, lalu perkecil kembali. Membagi dengan 100.0 (sebuah double), bukan 100, membuat angka desimalnya tetap ada:

public class Main {
    public static void main(String[] args) {
        double price = 19.4567;

        System.out.println(Math.round(price * 100) / 100.0);   // 19.46
        System.out.println(Math.round(price * 100) / 100);     // 19

        System.out.println(String.format("%.2f", price));      // 19.46
    }
}

Baris kedua membagi long dengan int, yang merupakan pembagian bilangan bulat, jadi angka desimalnya hilang. Kalau kamu hanya perlu menampilkan angka yang sudah dibulatkan, String.format("%.2f", value) lebih sederhana dan tidak mengubah nilai yang tersimpan.

Math.random: Angka Acak

Math.random() mengembalikan double yang paling kecil 0.0 dan kurang dari 1.0. Nilainya berbeda di setiap pemanggilan, jadi output program-program di bagian ini berubah setiap kali kamu menekan Jalankan.

public class Main {
    public static void main(String[] args) {
        double r = Math.random();
        System.out.println(r);
        System.out.println(r >= 0.0 && r < 1.0);   // true
    }
}

Untuk mendapatkan bilangan bulat dalam sebuah rentang, regangkan nilai itu, lakukan cast, lalu geser. Untuk bilangan bulat dari min sampai max, keduanya termasuk:

int value = (int) (Math.random() * (max - min + 1)) + min;

Begini cara kerjanya untuk sebuah dadu, dengan min bernilai 1 dan max bernilai 6:

1. Math.random() * 6 menghasilkan double dari 0.0 sampai mendekati, tetapi tidak termasuk, 6.0.
2. (int) membuang pecahannya, menghasilkan salah satu dari 0, 1, 2, 3, 4, 5.
3. + 1 menggesernya menjadi 1, 2, 3, 4, 5, 6.

public class Main {
    public static void main(String[] args) {
        int min = 1;
        int max = 6;

        for (int i = 0; i < 5; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            System.out.print(roll + " ");
        }
        System.out.println();

        int lowest = max;
        int highest = min;
        for (int i = 0; i < 10000; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            lowest = Math.min(lowest, roll);
            highest = Math.max(highest, roll);
        }
        System.out.println("lowest: " + lowest + ", highest: " + highest);
    }
}

Baris pertama menampilkan lima lemparan acak. Baris kedua memeriksa sepuluh ribu lemparan dan, dalam praktiknya, selalu mencetak lowest: 1, highest: 6: rumus itu menjangkau kedua ujung rentang dan tidak pernah melewatinya.

Tanda kurung di sekitar Math.random() * (max - min + 1) itu penting. Cast berlaku pada nilai yang tepat berada setelahnya, jadi (int) Math.random() * 6 melakukan cast pada Math.random() terlebih dahulu. Hasilnya selalu 0, dan 0 * 6 adalah 0, jadi setiap "lemparan" hasilnya sama.

Math.random() cukup untuk game dan latihan. Untuk keperluan yang lebih dari itu, class java.util.Random dan ThreadLocalRandom.current().nextInt(min, max + 1) (di java.util.concurrent) langsung mengembalikan bilangan bulat, dan Random bisa menerima seed untuk mengulang urutan yang sama saat pengujian. Tidak satu pun dari semua itu cocok untuk password atau token keamanan; pakai java.security.SecureRandom untuk keperluan tersebut.

Math.PI dan Math.E

Math.PI (π) dan Math.E (bilangan Euler e) adalah konstanta static final double:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.PI);   // 3.141592653589793
        System.out.println(Math.E);    // 2.718281828459045

        double radius = 3;
        double area = Math.PI * radius * radius;
        double circumference = 2 * Math.PI * radius;

        System.out.printf("area: %.2f%n", area);                     // area: 28.27
        System.out.printf("circumference: %.2f%n", circumference);   // circumference: 18.85
    }
}

Pakai keduanya, jangan mengetik 3.14. Presisinya setinggi yang bisa ditampung double, dan namanya memberi tahu pembaca angka apa itu.

Hasil Integer vs Hasil Double

Sebagian besar method Math menerima dan mengembalikan double. Saat kamu memberinya nilai int, Java otomatis memperlebar argumennya menjadi double, tetapi aritmetika yang kamu tulis sebelum pemanggilan tetap terjadi dalam int. Dari sinilah sebagian besar jawaban yang salah berasal:

public class Main {
    public static void main(String[] args) {
        int items = 7;
        int perBox = 2;

        System.out.println(Math.ceil(items / perBox));            // 3.0 (wrong)
        System.out.println(Math.ceil((double) items / perBox));   // 4.0

        System.out.println(Math.sqrt(10 / 4));     // 1.4142135623730951
        System.out.println(Math.sqrt(10 / 4.0));   // 1.5811388300841898

        int boxes = (int) Math.ceil((double) items / perBox);
        System.out.println(boxes + " boxes");      // 4 boxes
    }
}

items / perBox adalah 7 / 2, dan membagi dua nilai int membuang sisanya, jadi hasilnya 3 bahkan sebelum Math.ceil melihatnya. Math.ceil(3.0) adalah 3.0. Jadikan salah satu operand bertipe double, dengan cast atau literal seperti 4.0, supaya pembagiannya tetap menyimpan pecahan. Halaman operator menjelaskan pembagian bilangan bulat lebih rinci.

Aturan umumnya: tentukan tipe apa yang kamu inginkan di akhir, buat pembagian atau perkalian terjadi dalam double saat pecahan itu penting, lalu cast kembali ke int atau long hanya sekali, di bagian akhir.

Method Berguna Lainnya

Beberapa method lain dari class yang sama, semuanya dipanggil dengan cara yang sama:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.log10(1000));      // 3.0
        System.out.println(Math.log(Math.E));      // 1.0 (natural log)
        System.out.println(Math.signum(-4.2));     // -1.0

        System.out.println(-7 % 3);                // -1
        System.out.println(Math.floorMod(-7, 3));  // 2

        double angle = Math.toRadians(90);
        System.out.println(Math.sin(angle));       // 1.0

        try {
            Math.addExact(Integer.MAX_VALUE, 1);
        } catch (ArithmeticException e) {
            System.out.println("overflow: " + e.getMessage());   // overflow: integer overflow
        }
    }
}

• Math.log adalah logaritma natural; Math.log10 berbasis 10.
• Math.floorMod(a, b) memberikan sisa bagi dengan tanda milik b, yang memang kamu inginkan untuk berputar dalam sebuah rentang, misalnya hari dalam seminggu. Operator % mempertahankan tanda milik a.
• Method trigonometri (sin, cos, tan) menerima radian. Ubah derajat dengan Math.toRadians terlebih dahulu.
• Math.addExact, Math.multiplyExact, dan saudara-saudaranya melempar ArithmeticException saat terjadi overflow, bukan diam-diam berputar balik menjadi bilangan negatif.