Çalıştırılabilir Java Dokümanları: Math Sınıfı

Q: Java'da Math.pow nasıl kullanılır?

Math.pow(base, exponent), base'in exponent'inci kuvvetini double olarak döndürür, yani Math.pow(2, 3) sonucu 8.0'dır. Sonucu bir int'te saklamak için dönüştürün: int n = (int) Math.pow(2, 10); 1024 verir. Java'da ^ diye bir üs operatörü yoktur; ^ bit düzeyinde XOR'dur.

Q: Math.random ile belirli bir aralıkta rastgele sayı nasıl üretilir?

Math.random(), 0.0 ile 1.0 arasında (1.0 hariç) bir double döndürür. min ile max arasında (ikisi de dahil) bir tam sayı için (int) (Math.random() (max - min + 1)) + min kullanın. Bir zar atışı (int) (Math.random() 6) + 1 olur.

Q: Java'da Math sınıfını import etmem gerekir mi?

Hayır. Math, her Java dosyasının otomatik olarak import ettiği java.lang paketindedir. Tüm metotları static olduğu için onları nesne oluşturmadan sınıf adı üzerinden çağırırsınız, örneğin Math.sqrt(16).

Q: Java'da Math.round neden long döndürür?

Math.round(double) bir long döndürür, çünkü bir double bir int'in tutabileceğinden çok daha büyük değerler tutabilir. Sonucu bir int'e atamak dönüşüm gerektirir: int n = (int) Math.round(2.6);. Math.round(float) ise bir int döndürür.

Q: Math.floor, Math.ceil ve Math.round arasındaki fark nedir?

Math.floor aşağı yuvarlar (2.7, 2.0 olur; -2.3, -3.0 olur), Math.ceil yukarı yuvarlar (2.1, 3.0 olur), Math.round ise en yakın tam sayıya gider ve tam yarılar yukarı yuvarlanır (2.5, 3 olur). floor ve ceil bir double, round ise bir long döndürür.

Statik Metotlardan Oluşan Bir Araç Kutusu

java.lang.Math, hazır matematik fonksiyonlarıyla dolu bir sınıftır: üsler, kökler, mutlak değerler, yuvarlama, trigonometri, logaritmalar ve rastgele sayılar. Kullanımını iki şey kolaylaştırır:

Her Java dosyasının otomatik olarak import ettiği java.lang paketinde bulunur. Yazmanız gereken bir import satırı yoktur.
Her metodu static'tir. Onu sınıf adı üzerinden çağırırsınız (Math.sqrt(25)) ve hiçbir zaman bir Math nesnesi oluşturmazsınız. static'in ne anlama geldiğini static üyeler sayfası açıklıyor.

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
    }
}

Bazı sonuçların .0 ile yazdırıldığına, bazılarının ise yazdırılmadığına dikkat edin. Her Math metodunun sabit bir dönüş türü vardır ve bu sınıf hakkında öğrenilecek şeylerin çoğu bu türleri bilmektir.

Metot	Ne yapar	Döndürdüğü
`Math.pow(a, b)`	a'nın b'inci kuvveti	`double`
`Math.sqrt(x)`	karekök	`double`
`Math.cbrt(x)`	küpkök	`double`
`Math.abs(x)`	mutlak değer	`x` ile aynı tür
`Math.max(a, b)` / `Math.min(a, b)`	ikisinden büyüğü / küçüğü	iki türden daha geniş olanı
`Math.round(x)`	en yakın tam sayı	`double` için `long`, `float` için `int`
`Math.floor(x)` / `Math.ceil(x)`	aşağı yuvarlama / yukarı yuvarlama	`double`
`Math.random()`	0.0 ile 1.0 arasında rastgele sayı	`double`
`Math.PI`, `Math.E`	π ve e sabitleri	`double`

Math.pow: Üs Alma

Math.pow(base, exponent) bir sayının kuvvetini alır. İki double parametre alır ve tam sayı verseniz bile bir double döndürür:

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 (bir karekök)

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

Sonucu bir int'te saklamak için (int) ile dönüştürün. Küçük tam sayı kuvvetlerinde double sonuç tamdır, bu yüzden dönüşüm doğru cevabı verir. Dönüşümün yanlış gittiği yer büyük sonuçlardır: Integer.MAX_VALUE (2,147,483,647) değerinden büyük bir double tam olarak Integer.MAX_VALUE'ya dönüştürülür, yani (int) Math.pow(2, 40) sonucu 2147483647 olur. Daha büyük kuvvetler için long'a dönüştürün ve 2⁵³'ün üzerinde bir double'ın her tam sayıyı tam olarak temsil edemeyeceğini unutmayın. Dönüşümün değere ne yaptığını tür dönüşümü sayfası anlatıyor.

Java'da üs operatörü yoktur. 2 ^ 3 derlenir, ama ^ bit düzeyinde XOR'dur ve sonuç 8 değil, 1'dir. Bu, Java matematik kodunda yeni başlayanların en sık yaptığı hatalardan biridir.

On milyon ve üzeri bir double bilimsel gösterimle yazdırılır; bu da ilk kez onun bir kuvvetini yazdıranları şaşırtır:

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, 1.0 × 10⁷ anlamına gelir. Değer aynıdır; yalnızca yazdırılma biçimi değişir. Düz rakamlarla yazdırmak için long'a dönüştürün ya da String.format("%.0f", value) ile biçimlendirin.

Math.sqrt ve Math.cbrt: Kökler

Math.sqrt(x), x'in karekökünü double olarak döndürür. Math.cbrt(x) küpkökü döndürür.

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
    }
}

Negatif bir sayının karekökü gerçek bir sayı değildir, bu yüzden Math.sqrt(-4) exception fırlatmak yerine NaN ("not a number", sayı değil) döndürür. NaN dokunduğu her aritmetik işleme yayılır; negatif değerler mümkünse kök almadan önce girdileri kontrol edin. Math.hypot(a, b), sqrt(a*a + b*b)'yi doğrudan hesaplar; iki nokta arasındaki uzaklığı bulmanın yaygın bir yoludur.

Math.abs: Mutlak Değer

Math.abs(x) işareti kaldırır. pow ve sqrt'nin aksine verdiğiniz türü döndürür: int için int, double için 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
    }
}

Olağan kullanımı, yönün değil büyüklüğün önemli olduğu bir farktır; iki konum arasındaki uzaklık gibi.

Math.max ve Math.min

Math.max(a, b) iki değerden büyüğünü, Math.min(a, b) küçüğünü döndürür. Tam olarak iki argüman alırlar. Üç ya da daha fazlası için çağrıları iç içe yazın:

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
    }
}

İki argümanın türü farklıysa önce dar olan genişletilir. Math.max(3, 7.5) iki double değeri karşılaştırır ve bir double döndürür. Son örnek bir değeri 0 ile 100 aralığına sıkıştırır: Math.min onu 100'de sınırlar, Math.max da 0'ın altına düşmesini engeller.

Yuvarlama: round, floor, ceil

Java'da üç yuvarlama metodu vardır ve hem yön hem de dönüş türü bakımından farklıdırlar:

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 en yakın tam sayıya gider. Tam ortadaki bir değer yukarı, yani pozitif sonsuza doğru yuvarlanır; böylece 2.5, 3 olur ve -2.5, -2 olur. double argüman için bir long döndürür (float için bir int).
Math.floor her zaman aşağı, negatif sonsuza doğru yuvarlar ve bir double döndürür.
Math.ceil her zaman yukarı, pozitif sonsuza doğru yuvarlar ve bir double döndürür.
(int) dönüşümü hiç yuvarlama değildir: kesirli kısmı atar, bu da pozitif sayıları aşağı, negatif sayıları yukarı taşır.

Math.round(double) bir long döndürdüğü için sonucu bir int'e atamak dönüşüm olmadan derlenmez:

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 3 olur
long k = Math.round(2.6);         // OK

Belirli bir ondalık basamağa yuvarlamak için büyütün, yuvarlayın ve geri küçültün. 100 yerine 100.0'a (bir double) bölmek ondalıkları korur:

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
    }
}

İkinci satır bir long'u bir int'e böler; bu tam sayı bölmesidir, bu yüzden ondalıklar kaybolur. Yuvarlanmış bir sayıyı yalnızca göstermeniz gerekiyorsa String.format("%.2f", value) daha basittir ve saklanan değeri değiştirmez.

Math.random: Rastgele Sayılar

Math.random(), en az 0.0 ve 1.0'dan küçük bir double döndürür. Değer her çağrıda farklıdır, bu yüzden bu bölümdeki programların çıktısı Run'a her bastığınızda değişir.

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
    }
}

Bir aralıkta tam sayı elde etmek için bu değeri genişletin, dönüştürün ve kaydırın. min ile max arasında, ikisi de dahil bir tam sayı için:

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

min'in 1, max'ın 6 olduğu bir zarda bu şöyle işler:

Math.random() * 6, 0.0 ile 6.0 arasında (6.0 hariç) bir double verir.
(int) kesirli kısmı atar ve 0, 1, 2, 3, 4, 5 değerlerinden birini verir.
+ 1 bunu 1, 2, 3, 4, 5, 6 aralığına kaydırır.

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);
    }
}

İlk satır beş rastgele atış gösterir. İkinci satır on bin atışı kontrol eder ve pratikte her zaman lowest: 1, highest: 6 yazdırır: formül aralığın iki ucuna da ulaşır ve asla dışına çıkmaz.

Math.random() * (max - min + 1) etrafındaki parantezler önemlidir. Bir dönüşüm hemen ardından gelen değere uygulanır, bu yüzden (int) Math.random() * 6 önce Math.random()'u dönüştürür. Bu her zaman 0'dır ve 0 * 6 da 0'dır; dolayısıyla her "atış" aynı çıkar.

Math.random() oyunlar ve alıştırmalar için yeterlidir. Daha fazlası için java.util.Random sınıfı ve ThreadLocalRandom.current().nextInt(min, max + 1) (java.util.concurrent içinde) doğrudan tam sayı döndürür; Random testlerde aynı diziyi tekrarlamak için bir seed de alabilir. Bunların hiçbiri parolalar ya da güvenlik token'ları için uygun değildir; onlar için java.security.SecureRandom kullanın.

Math.PI ve Math.E

Math.PI (π) ve Math.E (Euler sayısı e), static final double sabitleridir:

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
    }
}

3.14 yazmak yerine bunları kullanın. Bir double'ın izin verdiği kadar hassastırlar ve adları okuyana sayının ne olduğunu söyler.

Tam Sayı Sonuçları ve Double Sonuçları

Math metotlarının çoğu double alır ve double döndürür. Onlara int değerler verdiğinizde Java argümanları otomatik olarak double'a genişletir, ama çağrıdan önce yazdığınız aritmetik yine int ile yapılır. Yanlış cevapların çoğu buradan gelir:

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

        System.out.println(Math.ceil(items / perBox));            // 3.0 (yanlış)
        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, 7 / 2'dir ve iki int değeri bölmek kalanı atar; bu yüzden sonuç Math.ceil onu görmeden önce 3 olur. Math.ceil(3.0), 3.0'dır. Bölmenin kesirli kısmı koruması için işlenenlerden birini bir dönüşümle ya da 4.0 gibi bir literal ile double yapın. Tam sayı bölmesini operatörler sayfası daha ayrıntılı açıklıyor.

Genel kural: sonunda hangi türü istediğinize karar verin, kesirler önemliyse bölmenin ya da çarpmanın double ile yapılmasını sağlayın ve int ya da long'a yalnızca bir kez, en sonda geri dönüştürün.

Diğer Kullanışlı Metotlar

Aynı sınıftan, hepsi aynı şekilde çağrılan birkaç metot daha:

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 (doğal logaritma)
        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 doğal logaritmadır; Math.log10 10 tabanındadır.
Math.floorMod(a, b), işareti b'nin işaretiyle aynı olan bir kalan verir; haftanın günleri gibi bir aralıkta başa sarmak için istediğiniz de budur. % operatörü a'nın işaretini korur.
Trigonometri metotları (sin, cos, tan) radyan alır. Dereceleri önce Math.toRadians ile dönüştürün.
Math.addExact, Math.multiplyExact ve benzerleri taşma olduğunda sessizce negatif bir sayıya sarmak yerine bir ArithmeticException fırlatır.

Sıkça Sorulan Sorular

Java'da Math.pow nasıl kullanılır?

Math.pow(base, exponent), base'in exponent'inci kuvvetini double olarak döndürür, yani Math.pow(2, 3) sonucu 8.0'dır. Sonucu bir int'te saklamak için dönüştürün: int n = (int) Math.pow(2, 10); 1024 verir. Java'da ^ diye bir üs operatörü yoktur; ^ bit düzeyinde XOR'dur.

Math.random ile belirli bir aralıkta rastgele sayı nasıl üretilir?

Math.random(), 0.0 ile 1.0 arasında (1.0 hariç) bir double döndürür. min ile max arasında (ikisi de dahil) bir tam sayı için (int) (Math.random() * (max - min + 1)) + min kullanın. Bir zar atışı (int) (Math.random() * 6) + 1 olur.

Java'da Math sınıfını import etmem gerekir mi?

Hayır. Math, her Java dosyasının otomatik olarak import ettiği java.lang paketindedir. Tüm metotları static olduğu için onları nesne oluşturmadan sınıf adı üzerinden çağırırsınız, örneğin Math.sqrt(16).

Java'da Math.round neden long döndürür?

Math.round(double) bir long döndürür, çünkü bir double bir int'in tutabileceğinden çok daha büyük değerler tutabilir. Sonucu bir int'e atamak dönüşüm gerektirir: int n = (int) Math.round(2.6);. Math.round(float) ise bir int döndürür.

Math.floor, Math.ceil ve Math.round arasındaki fark nedir?

Math.floor aşağı yuvarlar (2.7, 2.0 olur; -2.3, -3.0 olur), Math.ceil yukarı yuvarlar (2.1, 3.0 olur), Math.round ise en yakın tam sayıya gider ve tam yarılar yukarı yuvarlanır (2.5, 3 olur). floor ve ceil bir double, round ise bir long döndürür.