Klasa Java Math i jej metody

W tym artykule dokonamy krótkiego przeglądu klasy Math w Javie. Porozmawiajmy o metodach tej klasy i o tym, jak z nich korzystać. Klasa Math znajduje się w pakiecie java.lang i udostępnia zestaw metod statycznych do wykonywania szeregu różnych obliczeń matematycznych. Poniżej znajdują się przykłady obliczeń, do których przydatna może być klasa Math:

• Obliczanie wartości bezwzględnych (wartości modulo)
• Obliczanie wartości funkcji trygonometrycznych (sinusów, cosinusów itp.)
• Elewacja w różnym stopniu
• Wyrywanie korzeni różnego stopnia
• Generowanie liczb losowych
• Zaokrąglanie
• Itp.

Poniżej postaramy się sprawdzić, jak klasa Java Math pomaga rozwiązać wymienione powyżej problemy. Zacznijmy analizę klasy od metod, które pozwalają obliczyć wartość modulo. Odpowiada za to metoda abs. Ta metoda jest przeciążona, a klasa Math ma następujące różnice:

• statyczny podwójny abs (podwójny a)
• statyczny pływak abs (pływak a)
• statyczny int abs(int a)
• statyczny długi brzuch (długi a)

Przykład użycia:

public static void main(String[] args) {
        System.out.println(Math.abs(-1));      // 1
        System.out.println(Math.abs(-21.8d));  // 21.8
        System.out.println(Math.abs(4532L));   // 4532
        System.out.println(Math.abs(5.341f));  // 5.341
    }

Obliczanie funkcji trygonometrycznych

Klasa Math umożliwia obliczanie różnych funkcji trygonometrycznych - sinusów, cosinusów, tangensów itp. Pełną listę metod można znaleźć na oficjalnej stronie dokumentacji . Poniżej znajduje się lista tych metod:

• statyczny podwójny grzech (podwójne a)
• statyczny podwójny cos(podwójny a)
• statyczna podwójna opalenizna (podwójne a)
• statyczny podwójny asin(podwójny a)
• statyczne podwójne acos (podwójne a)
• statyczny podwójny atan(podwójne a)

Metody obliczania: sinus, cosinus, tangens, arcsinus, arccosinus, arcustangens. Każda metoda oblicza wartość kąta „a”. Parametr ten przekazywany jest do każdej metody i w każdym przypadku mierzony jest w radianach (a nie, jak jesteśmy przyzwyczajeni, w stopniach). Są tu dwie wiadomości, dobra i zła. Zacznijmy od tego dobrego. Klasa Math zawiera metody konwertowania radianów na stopnie i stopni na radiany:

• statyczny podwójny do stopni (podwójny angrad)
• statyczny podwójny toRadians (podwójny angdeg)

W tym przypadku metoda toDegrees przeliczy kąt angrad mierzony w radianach na stopnie. Natomiast metoda toRadians przekształca kąt angdeg mierzony w stopniach na radiany. Zła wiadomość jest taka, że ​​dzieje się tak z powodu jakiegoś błędu. Oto przykład obliczenia sinusów i cosinusów:

public static void main(String[] args) {
        System.out.println(Math.sin(Math.toRadians(0)));
        System.out.println(Math.sin(Math.toRadians(30)));
        System.out.println(Math.sin(Math.toRadians(90)));

        System.out.println(Math.cos(Math.toRadians(0)));
        System.out.println(Math.cos(Math.toRadians(30)));
        System.out.println(Math.cos(Math.toRadians(90)));
    }

Program wyświetli:

0.0
0.49999999999999994
1.0

1.0
0.8660254037844387
6.123233995736766E-17

Co nie do końca odpowiada tablicom sinusów i cosinusów, częściowo z powodu błędów w konwersji stopni na radiany.

Potęgowanie

Aby podnieść liczbę do potęgi, klasa Math udostępnia metodę pow, która ma następującą sygnaturę:

static double pow(double a, double b)

Ta metoda podnosi parametr „a” do potęgi „b”. Przykłady:

public static void main(String[] args) {
        System.out.println(Math.pow(1,2)); // 1.0
        System.out.println(Math.pow(2,2)); // 4.0
        System.out.println(Math.pow(3,2)); // 9.0
        System.out.println(Math.pow(4,2)); // 16.0
        System.out.println(Math.pow(5,2)); // 25.0

        System.out.println(Math.pow(1,3)); // 1.0
        System.out.println(Math.pow(2,3)); // 8.0
        System.out.println(Math.pow(3,3)); // 27.0
        System.out.println(Math.pow(4,3)); // 64.0
        System.out.println(Math.pow(5,3)); // 125.0
    }

Ekstrakcja korzeni

Klasa Math udostępnia metody obliczania pierwiastków kwadratowych i sześciennych. Za tę procedurę odpowiedzialne są następujące metody:

• statyczny podwójny sqrt(podwójne a)
• statyczny podwójny cbrt(podwójny a)

Metoda sqrt pobiera pierwiastek kwadratowy, a metoda cbrt pierwiastek sześcienny. Przykłady:

public static void main(String[] args) {
        System.out.println(Math.sqrt(4));   // 2.0
        System.out.println(Math.sqrt(9));   // 3.0
        System.out.println(Math.sqrt(16));  // 4.0

        System.out.println(Math.cbrt(8));   // 2.0
        System.out.println(Math.cbrt(27));  // 3.0
        System.out.println(Math.cbrt(125)); // 5.0
    }

Generowanie liczb losowych

Aby wygenerować liczby losowe, klasa Math udostępnia metodę losową. Metoda ta generuje losową dodatnią liczbę rzeczywistą (podwójną) z zakresu od 0,0 do 1,0. Sygnatura metody wygląda następująco:

public static double random()

Spójrzmy na przykłady:

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        System.out.println(Math.random());
    }
}

Po wykonaniu metody main na konsoli wyświetliło się:

0.37057465028778513
0.2516253742011597
0.9315649439611121
0.6346725713527239
0.7442959932755443

Przy odrobinie manipulacji można użyć metody losowej klasy Math do uzyskania liczb losowych w postaci liczb całkowitych mieszczących się w określonym zakresie. Oto przykład funkcji, która przyjmuje dwa argumenty min i max i zwraca losową liczbę całkowitą z zakresu od min (włącznie) do max (włącznie):

static int randomInARange(int min, int max) {
    return  (int) (Math.random() * ((max - min) + 1)) + min;
}

Napiszmy metodę Main, w której przetestujemy metodę randomInARange:

public class MathExample {


    public static void main(String[] args) {
        // Карта, в которой мы будем хранить количество выпадений Jakого-то числа
        Map<Integer, Integer> map = new TreeMap<>();

        // За 10000 операций
        for (int i = 0; i < 10000; i++) {

            // Сгенерируем рандомное число от -10 включительно до 10 включительно
            final Integer randomNumber = randomInARange(-10, 10);


            if (!map.containsKey(randomNumber)) {
                // Если карта еще не содержит "выпавшего случайного числа"
                // Положим его в карту с кол-вом выпадений = 1
                map.put(randomNumber, 1);
            } else {
                // Иначе, увеличим количество выпадений данного числа на 1
                map.put(randomNumber, map.get(randomNumber) + 1);
            }
        }

        // Выведем на экран содержимое карты в формате ключ=[oznaczający]
        for (Map.Entry<Integer, Integer> entry : map.entrySet()){
            System.out.println(String.format("%d=[%d]", entry.getKey(), entry.getValue()));
        }
    }

    static int randomInARange(int min, int max) {
        return  (int) (Math.random() * ((max - min) + 1)) + min;
    }
}

Po uruchomieniu metody main wynik może wyglądać następująco:

-10=[482]
-9=[495]
-8=[472]
-7=[514]
-6=[457]
-5=[465]
-4=[486]
-3=[500]
-2=[490]
-1=[466]
0=[458]
1=[488]
2=[461]
3=[470]
4=[464]
5=[463]
6=[484]
7=[479]
8=[459]
9=[503]
10=[444]

Process finished with exit code 0

Zaokrąglanie

Do zaokrąglania liczb w Javie jednym z narzędzi są metody klasy Math. Dokładniej, metody okrągłe, sufitowe i podłogowe:

• statyczna długa runda (podwójna a)
• statyczny int okrągły (float a)
• statyczne podwójne piętro (podwójne a)
• statyczny podwójny sufit (podwójny a)

Metoda okrągła - zaokrągla jak zwykle do przeciętnego człowieka. Jeżeli część ułamkowa liczby jest większa lub równa 0,5, wówczas liczba zostanie zaokrąglona w górę, w przeciwnym razie w dół. Metoda podłogowa zawsze, niezależnie od wartości części ułamkowej, zaokrągla liczbę w dół (w stronę ujemnej nieskończoności). Natomiast metoda ceil, niezależnie od wartości części ułamkowej, zaokrągla liczby w górę (w kierunku dodatniej nieskończoności). Spójrzmy na przykłady:

public static void main(String[] args) {
    System.out.println(Math.round(1.3)); // 1
    System.out.println(Math.round(1.4)); // 1
    System.out.println(Math.round(1.5)); // 2
    System.out.println(Math.round(1.6)); // 2

    System.out.println(Math.floor(1.3)); // 1.0
    System.out.println(Math.floor(1.4)); // 1.0
    System.out.println(Math.floor(1.5)); // 1.0
    System.out.println(Math.floor(1.6)); // 1.0

    System.out.println(Math.ceil(1.3)); // 2.0
    System.out.println(Math.ceil(1.4)); // 2.0
    System.out.println(Math.ceil(1.5)); // 2.0
    System.out.println(Math.ceil(1.6)); // 2.0
}

Wniosek

W tym artykule przyjrzeliśmy się powierzchownie lekcjom matematycznym. Przyjrzeliśmy się, jak za pomocą tej klasy możesz:

• Oblicz wartości modulo;
• Oblicz wartości funkcji trygonometrycznych;
• Podnieś liczby do potęg;
• Wyodrębnij pierwiastki kwadratowe i sześcienne;
• Generuj liczby losowe;
• Okrągłe liczby.

W tej klasie jest wiele innych ciekawych metod. Które można znaleźć na oficjalnej stronie dokumentacji . Cóż, dla pierwszej znajomości metody wymienione powyżej są wystarczające.