Dokumentacja Java z przykładami: Klasa Math

Q: Jak używać Math.pow w Javie?

Math.pow(base, exponent) zwraca base podniesione do potęgi exponent jako double, więc Math.pow(2, 3) to 8.0. Aby zapisać wynik w int, zrzutuj go: int n = (int) Math.pow(2, 10); daje 1024. Java nie ma operatora potęgowania ^; ^ to bitowy XOR.

Q: Jak wylosować liczbę z zakresu za pomocą Math.random?

Math.random() zwraca double od 0.0 do 1.0, bez samego 1.0. Aby dostać liczbę całkowitą od min do max włącznie, użyj (int) (Math.random() (max - min + 1)) + min. Rzut kostką to (int) (Math.random() 6) + 1.

Q: Czy trzeba importować klasę Math w Javie?

Nie. Math należy do pakietu java.lang, który każdy plik Javy importuje automatycznie. Wszystkie jej metody są static, więc wywołujesz je na nazwie klasy, np. Math.sqrt(16), bez tworzenia obiektu.

Q: Dlaczego Math.round zwraca long w Javie?

Math.round(double) zwraca long, bo double może przechowywać wartości dużo większe niż int. Przypisanie wyniku do int wymaga rzutowania: int n = (int) Math.round(2.6);. Math.round(float) zwraca int.

Q: Czym różnią się Math.floor, Math.ceil i Math.round?

Math.floor zaokrągla w dół (2.7 daje 2.0, -2.3 daje -3.0), Math.ceil zaokrągla w górę (2.1 daje 3.0), a Math.round do najbliższej liczby całkowitej, przy czym połówki idą w górę (2.5 daje 3). floor i ceil zwracają double; round zwraca long.

Skrzynka z narzędziami: metody statyczne

java.lang.Math to klasa pełna gotowych funkcji matematycznych: potęgi, pierwiastki, wartości bezwzględne, zaokrąglanie, trygonometria, logarytmy i liczby losowe. Dwie rzeczy sprawiają, że łatwo jej używać:

Znajduje się w java.lang, który każdy plik Javy importuje automatycznie. Nie trzeba pisać żadnej linii import.
Każda metoda jest static. Wywołujesz ją na nazwie klasy, Math.sqrt(25), i nigdy nie tworzysz obiektu Math. Strona o składowych statycznych wyjaśnia, co oznacza 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
    }
}

Zwróć uwagę, że niektóre wyniki są wypisywane z .0, a inne nie. Każda metoda Math ma stały typ zwracany i jego znajomość to większość tego, czego trzeba się nauczyć o tej klasie.

Metoda	Co robi	Zwraca
`Math.pow(a, b)`	a do potęgi b	`double`
`Math.sqrt(x)`	pierwiastek kwadratowy	`double`
`Math.cbrt(x)`	pierwiastek sześcienny	`double`
`Math.abs(x)`	wartość bezwzględna	ten sam typ co `x`
`Math.max(a, b)` / `Math.min(a, b)`	większa / mniejsza z dwóch	szerszy z dwóch typów
`Math.round(x)`	najbliższa liczba całkowita	`long` dla `double`, `int` dla `float`
`Math.floor(x)` / `Math.ceil(x)`	zaokrąglenie w dół / w górę	`double`
`Math.random()`	liczba losowa od 0.0 do 1.0	`double`
`Math.PI`, `Math.E`	stałe π i e	`double`

Math.pow: potęgi

Math.pow(base, exponent) podnosi liczbę do potęgi. Przyjmuje dwa parametry double i zwraca double, nawet gdy przekazujesz liczby całkowite:

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 (pierwiastek kwadratowy)

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

Aby zapisać wynik w int, zrzutuj go przez (int). Dla małych potęg całkowitych wynik double jest dokładny, więc rzutowanie daje poprawną odpowiedź. Problem pojawia się przy dużych wynikach: double większy niż Integer.MAX_VALUE (2 147 483 647) po rzutowaniu daje dokładnie Integer.MAX_VALUE, więc (int) Math.pow(2, 40) daje 2147483647. Przy większych potęgach rzutuj na long i pamiętaj, że powyżej 2⁵³ double nie potrafi dokładnie przedstawić każdej liczby całkowitej. Strona o rzutowaniu typów opisuje, co rzutowanie robi z wartością.

Java nie ma operatora potęgowania. 2 ^ 3 się kompiluje, ale ^ to bitowy XOR, a wynik to 1, nie 8. To jeden z najczęstszych błędów początkujących w kodzie matematycznym w Javie.

double równy dziesięć milionów lub więcej wypisuje się w notacji naukowej, co zaskakuje przy pierwszym wypisaniu potęgi dziesięciu:

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 oznacza 1.0 × 10⁷. Wartość jest ta sama, zmienia się tylko sposób wypisania. Aby wypisać ją jako zwykłe cyfry, zrzutuj ją na long albo sformatuj przez String.format("%.0f", value).

Math.sqrt i Math.cbrt: pierwiastki

Math.sqrt(x) zwraca pierwiastek kwadratowy z x jako double. Math.cbrt(x) zwraca pierwiastek sześcienny.

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

Pierwiastek kwadratowy z liczby ujemnej nie jest liczbą rzeczywistą, więc Math.sqrt(-4) zwraca NaN ("not a number", czyli "nie liczba") zamiast rzucać wyjątek. NaN rozprzestrzenia się na każde działanie, którego dotknie, więc jeśli możliwe są wartości ujemne, sprawdzaj dane przed liczeniem pierwiastka. Math.hypot(a, b) liczy bezpośrednio sqrt(a*a + b*b), co jest popularnym sposobem na odległość między dwoma punktami.

Math.abs: wartość bezwzględna

Math.abs(x) usuwa znak. W odróżnieniu od pow i sqrt zwraca ten sam typ, który dostaje: int dla int, double dla 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
    }
}

Typowe zastosowanie to różnica, w której liczy się wielkość, a nie kierunek, np. odległość między dwiema pozycjami.

Math.max i Math.min

Math.max(a, b) zwraca większą z dwóch wartości, a Math.min(a, b) mniejszą. Przyjmują dokładnie dwa argumenty. Dla trzech lub więcej zagnieżdżaj wywołania:

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

Gdy dwa argumenty mają różne typy, węższy jest najpierw rozszerzany. Math.max(3, 7.5) porównuje dwie wartości double i zwraca double. Ostatni przykład ogranicza wartość do zakresu od 0 do 100: Math.min przycina ją do 100, a Math.max nie pozwala jej spaść poniżej 0.

Zaokrąglanie: round, floor, ceil

Java ma trzy metody zaokrąglania i różnią się zarówno kierunkiem, jak i typem zwracanym:

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 zaokrągla do najbliższej liczby całkowitej. Wartość dokładnie w połowie zaokrągla się w górę, w stronę plus nieskończoności, więc 2.5 daje 3, a -2.5 daje -2. Dla argumentu double zwraca long (a dla float zwraca int).
Math.floor zawsze zaokrągla w dół, w stronę minus nieskończoności, i zwraca double.
Math.ceil zawsze zaokrągla w górę, w stronę plus nieskończoności, i zwraca double.
Rzutowanie (int) w ogóle nie jest zaokrąglaniem: odcina część ułamkową, co przesuwa liczby dodatnie w dół, a ujemne w górę.

Ponieważ Math.round(double) zwraca long, przypisanie wyniku do int bez rzutowania się nie kompiluje:

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

Aby zaokrąglić do określonej liczby miejsc po przecinku, pomnóż, zaokrąglij i podziel z powrotem. Dzielenie przez 100.0 (double) zamiast przez 100 zachowuje część dziesiętną:

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

Druga linia dzieli long przez int, czyli wykonuje dzielenie całkowite, więc część dziesiętna przepada. Jeśli zaokrągloną liczbę trzeba tylko wyświetlić, String.format("%.2f", value) jest prostsze i nie zmienia przechowywanej wartości.

Math.random: liczby losowe

Math.random() zwraca double, który jest co najmniej 0.0 i mniejszy niż 1.0. Przy każdym wywołaniu wartość jest inna, więc wynik programów w tej sekcji zmienia się po każdym kliknięciu Run.

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

Aby dostać liczbę całkowitą z zakresu, rozciągnij tę wartość, zrzutuj ją i przesuń. Dla liczby całkowitej od min do max, oba końce włącznie:

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

Tak to działa dla kostki, gdzie min to 1, a max to 6:

Math.random() * 6 daje double od 0.0 do 6.0, bez samego 6.0.
(int) odcina część ułamkową, co daje jedną z wartości 0, 1, 2, 3, 4, 5.
+ 1 przesuwa ją do 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);
    }
}

Pierwsza linia pokazuje pięć losowych rzutów. Druga sprawdza dziesięć tysięcy rzutów i w praktyce zawsze wypisuje lowest: 1, highest: 6: wzór dochodzi do obu końców zakresu i nigdy ich nie przekracza.

Nawiasy wokół Math.random() * (max - min + 1) mają znaczenie. Rzutowanie dotyczy wartości tuż po nim, więc (int) Math.random() * 6 najpierw rzutuje Math.random(). To zawsze daje 0, a 0 * 6 to 0, więc każdy "rzut" wychodzi taki sam.

Math.random() wystarcza do gier i ćwiczeń. W innych przypadkach klasa java.util.Random i ThreadLocalRandom.current().nextInt(min, max + 1) (w java.util.concurrent) zwracają liczby całkowite bezpośrednio, a Random może przyjąć ziarno (seed), aby w testach powtarzać tę samą sekwencję. Żadna z nich nie nadaje się do haseł ani tokenów bezpieczeństwa; do tego służy java.security.SecureRandom.

Math.PI i Math.E

Math.PI (π) i Math.E (liczba Eulera e) to stałe 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
    }
}

Używaj ich zamiast wpisywać 3.14. Są tak dokładne, jak pozwala double, a nazwa mówi czytelnikowi, czym jest liczba.

Wyniki całkowite a wyniki double

Większość metod Math przyjmuje i zwraca double. Gdy podajesz im wartości int, Java automatycznie rozszerza argumenty do double, ale działania zapisane przed wywołaniem nadal wykonują się na int. Stąd bierze się większość błędnych wyników:

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

        System.out.println(Math.ceil(items / perBox));            // 3.0 (błędnie)
        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 to 7 / 2, a dzielenie dwóch wartości int odrzuca resztę, więc wynik to 3, zanim Math.ceil w ogóle go zobaczy. Math.ceil(3.0) to 3.0. Zamień jeden z operandów na double, rzutowaniem albo literałem takim jak 4.0, aby dzielenie zachowało część ułamkową. Strona o operatorach wyjaśnia dokładniej dzielenie całkowite.

Ogólna zasada: zdecyduj, jaki typ chcesz mieć na końcu, wykonuj dzielenie lub mnożenie na double, gdy liczą się ułamki, i rzutuj z powrotem na int albo long tylko raz, na samym końcu.

Inne przydatne metody

Kilka kolejnych metod z tej samej klasy, wywoływanych w ten sam sposób:

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 (logarytm naturalny)
        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 to logarytm naturalny; Math.log10 to logarytm dziesiętny.
Math.floorMod(a, b) daje resztę ze znakiem b, czyli to, czego potrzebujesz przy zawijaniu w obrębie zakresu, np. dni tygodnia. Operator % zachowuje znak a.
Metody trygonometryczne (sin, cos, tan) przyjmują radiany. Stopnie najpierw zamień przez Math.toRadians.
Math.addExact, Math.multiplyExact i pokrewne rzucają ArithmeticException przy przepełnieniu, zamiast po cichu przeskoczyć do liczby ujemnej.

Najczęściej zadawane pytania

Jak używać Math.pow w Javie?

Math.pow(base, exponent) zwraca base podniesione do potęgi exponent jako double, więc Math.pow(2, 3) to 8.0. Aby zapisać wynik w int, zrzutuj go: int n = (int) Math.pow(2, 10); daje 1024. Java nie ma operatora potęgowania ^; ^ to bitowy XOR.

Jak wylosować liczbę z zakresu za pomocą Math.random?

Math.random() zwraca double od 0.0 do 1.0, bez samego 1.0. Aby dostać liczbę całkowitą od min do max włącznie, użyj (int) (Math.random() * (max - min + 1)) + min. Rzut kostką to (int) (Math.random() * 6) + 1.

Czy trzeba importować klasę Math w Javie?

Nie. Math należy do pakietu java.lang, który każdy plik Javy importuje automatycznie. Wszystkie jej metody są static, więc wywołujesz je na nazwie klasy, np. Math.sqrt(16), bez tworzenia obiektu.

Dlaczego Math.round zwraca long w Javie?

Math.round(double) zwraca long, bo double może przechowywać wartości dużo większe niż int. Przypisanie wyniku do int wymaga rzutowania: int n = (int) Math.round(2.6);. Math.round(float) zwraca int.

Czym różnią się Math.floor, Math.ceil i Math.round?

Math.floor zaokrągla w dół (2.7 daje 2.0, -2.3 daje -3.0), Math.ceil zaokrągla w górę (2.1 daje 3.0), a Math.round do najbliższej liczby całkowitej, przy czym połówki idą w górę (2.5 daje 3). floor i ceil zwracają double; round zwraca long.