תיעוד Java עם דוגמאות להרצה: המחלקה Math

Q: איך משתמשים ב-Math.pow ב-Java?

Math.pow(base, exponent) מחזירה את base בחזקת exponent בתור double, כך ש-Math.pow(2, 3) הוא 8.0. כדי לשמור את התוצאה ב-int, מבצעים המרה: int n = (int) Math.pow(2, 10); נותן 1024. ב-Java אין אופרטור חזקה ^; ^ הוא XOR ברמת הביטים.

Q: איך יוצרים מספר אקראי בטווח עם Math.random?

Math.random() מחזירה double מ-0.0 ועד 1.0, לא כולל. למספר שלם מ-min עד max כולל, משתמשים ב-(int) (Math.random() (max - min + 1)) + min. הטלת קובייה היא (int) (Math.random() 6) + 1.

Q: האם צריך לייבא את המחלקה Math ב-Java?

לא. Math נמצאת בחבילה java.lang, שכל קובץ Java מייבא אוטומטית. כל המתודות שלה הן static, ולכן קוראים להן על שם המחלקה, כמו Math.sqrt(16), בלי ליצור אובייקט.

Q: למה Math.round מחזירה long ב-Java?

Math.round(double) מחזירה long כי double יכול להכיל ערכים גדולים בהרבה מ-int. השמת התוצאה ל-int דורשת המרה: int n = (int) Math.round(2.6);. Math.round(float) מחזירה int.

Q: מה ההבדל בין Math.floor, Math.ceil ו-Math.round?

Math.floor מעגלת כלפי מטה (2.7 הופך ל-2.0, -2.3 הופך ל--3.0), Math.ceil מעגלת כלפי מעלה (2.1 הופך ל-3.0), ו-Math.round הולכת למספר השלם הקרוב ביותר, כשחצאים מתעגלים למעלה (2.5 הופך ל-3). floor ו-ceil מחזירות double; round מחזירה long.

ארגז כלים של מתודות סטטיות

java.lang.Math היא מחלקה מלאה בפונקציות מתמטיות מוכנות: חזקות, שורשים, ערך מוחלט, עיגול, טריגונומטריה, לוגריתמים ומספרים אקראיים. שני דברים הופכים אותה לנוחה:

היא נמצאת ב-java.lang, שכל קובץ Java מייבא אוטומטית. אין שורת import לכתוב.
כל מתודה היא static. קוראים לה על שם המחלקה, Math.sqrt(25), ואף פעם לא יוצרים אובייקט Math. העמוד על איברים סטטיים מסביר מה המשמעות של 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
    }
}

שימו לב שחלק מהתוצאות מודפסות עם .0 וחלק לא. לכל מתודה של Math יש טיפוס החזרה קבוע, ולהכיר אותו זה רוב מה שיש ללמוד על המחלקה הזו.

מתודה	מה היא עושה	מחזירה
`Math.pow(a, b)`	a בחזקת b	`double`
`Math.sqrt(x)`	שורש ריבועי	`double`
`Math.cbrt(x)`	שורש שלישי	`double`
`Math.abs(x)`	ערך מוחלט	אותו טיפוס כמו `x`
`Math.max(a, b)` / `Math.min(a, b)`	הגדול / הקטן מבין השניים	הרחב מבין שני הטיפוסים
`Math.round(x)`	המספר השלם הקרוב ביותר	`long` עבור `double`, `int` עבור `float`
`Math.floor(x)` / `Math.ceil(x)`	עיגול למטה / עיגול למעלה	`double`
`Math.random()`	מספר אקראי מ-0.0 ועד 1.0	`double`
`Math.PI`, `Math.E`	הקבועים π ו-e	`double`

Math.pow: חזקות

Math.pow(base, exponent) מעלה מספר בחזקה. היא מקבלת שני פרמטרים מסוג double ומחזירה double, גם כשמעבירים מספרים שלמים:

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 (שורש ריבועי)

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

כדי לשמור את התוצאה ב-int, ממירים אותה עם (int). בחזקות קטנות של מספרים שלמים תוצאת ה-double מדויקת, ולכן ההמרה נותנת את התשובה הנכונה. בתוצאות גדולות ההמרה משתבשת: double מעל Integer.MAX_VALUE (2,147,483,647) מומר בדיוק ל-Integer.MAX_VALUE, כך ש-(int) Math.pow(2, 40) נותן 2147483647. לחזקות גדולות יותר ממירים ל-long, וכדאי לזכור שמעל 2⁵³ double לא יכול לייצג כל מספר שלם במדויק. העמוד על המרת טיפוסים מסביר מה המרה עושה לערך.

ב-Java אין אופרטור חזקה. 2 ^ 3 עובר קומפילציה, אבל ^ הוא XOR ברמת הביטים, והתוצאה היא 1, לא 8. זה אחד הבאגים הנפוצים ביותר של מתחילים בקוד מתמטי ב-Java.

double של עשרה מיליון ומעלה מודפס בכתיב מדעי, מה שמפתיע אנשים בפעם הראשונה שהם מדפיסים חזקה של עשר:

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⁷. הערך זהה; רק צורת ההדפסה משתנה. כדי להדפיס אותו כספרות רגילות, ממירים ל-long או מעצבים עם String.format("%.0f", value).

Math.sqrt ו-Math.cbrt: שורשים

Math.sqrt(x) מחזירה את השורש הריבועי של x בתור double. Math.cbrt(x) מחזירה את השורש השלישי.

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

השורש הריבועי של מספר שלילי אינו מספר ממשי, ולכן Math.sqrt(-4) מחזירה NaN ("not a number") במקום לזרוק חריגה. NaN מתפשט דרך כל חישוב שהוא נוגע בו, אז אם ייתכנו ערכים שליליים, כדאי לבדוק את הקלט לפני הוצאת שורש. Math.hypot(a, b) מחשבת את sqrt(a*a + b*b) ישירות, וזו דרך נפוצה לקבל את המרחק בין שתי נקודות.

Math.abs: ערך מוחלט

Math.abs(x) מסירה את הסימן. בניגוד ל-pow ול-sqrt, היא מחזירה את אותו טיפוס שנותנים לה: int עבור int, double עבור 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
    }
}

השימוש הרגיל הוא בהפרש שבו חשוב הגודל ולא הכיוון, כמו המרחק בין שני מיקומים.

Math.max ו-Math.min

Math.max(a, b) מחזירה את הגדול מבין שני ערכים ו-Math.min(a, b) את הקטן. הן מקבלות בדיוק שני ארגומנטים. לשלושה ומעלה, מקננים את הקריאות:

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

כששני הארגומנטים מטיפוסים שונים, הצר מביניהם מורחב קודם. Math.max(3, 7.5) משווה שני ערכי double ומחזירה double. הדוגמה האחרונה מגבילה ערך לטווח 0 עד 100: Math.min חוסמת אותו ב-100, ו-Math.max לא נותנת לו לרדת מתחת ל-0.

עיגול: round, floor, ceil

ל-Java יש שלוש מתודות עיגול, והן שונות גם בכיוון וגם בטיפוס ההחזרה:

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 הולכת למספר השלם הקרוב ביותר. ערך שנמצא בדיוק באמצע מתעגל למעלה, לכיוון אינסוף חיובי, כך ש-2.5 הופך ל-3 ו--2.5 הופך ל--2. היא מחזירה long עבור ארגומנט double (ו-int עבור float).
Math.floor תמיד מעגלת למטה, לכיוון אינסוף שלילי, ומחזירה double.
Math.ceil תמיד מעגלת למעלה, לכיוון אינסוף חיובי, ומחזירה double.
המרה (int) היא בכלל לא עיגול: היא משמיטה את החלק השברי, מה שמזיז מספרים חיוביים למטה ומספרים שליליים למעלה.

מכיוון ש-Math.round(double) מחזירה long, השמה שלה ל-int לא עוברת קומפילציה בלי המרה:

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

כדי לעגל למספר מסוים של ספרות אחרי הנקודה, מגדילים, מעגלים ומקטינים בחזרה. חלוקה ב-100.0 (שהוא double) במקום ב-100 שומרת על הספרות העשרוניות:

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

השורה השנייה מחלקת long ב-int, וזו חלוקת שלמים, ולכן הספרות העשרוניות הולכות לאיבוד. כשצריך רק להציג מספר מעוגל, String.format("%.2f", value) פשוטה יותר ולא משנה את הערך השמור.

Math.random: מספרים אקראיים

Math.random() מחזירה double שהוא לפחות 0.0 וקטן מ-1.0. הערך שונה בכל קריאה, כך שהפלט של התוכניות בחלק הזה משתנה בכל פעם שלוחצים 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
    }
}

כדי לקבל מספר שלם בטווח, מותחים את הערך, ממירים אותו ומזיזים אותו. למספר שלם מ-min עד max, כולל שניהם:

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

כך זה עובד עבור קובייה, שבה min הוא 1 ו-max הוא 6:

Math.random() * 6 נותן double מ-0.0 ועד 6.0, לא כולל.
(int) משמיט את השבר, ונותן אחד מ-0, 1, 2, 3, 4, 5.
+ 1 מזיז את זה ל-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);
    }
}

השורה הראשונה מציגה חמש הטלות אקראיות. השורה השנייה בודקת עשרת אלפים הטלות ובפועל תמיד מדפיסה lowest: 1, highest: 6: הנוסחה מגיעה לשני קצוות הטווח ואף פעם לא חורגת מהם.

הסוגריים סביב Math.random() * (max - min + 1) חשובים. המרה חלה על הערך שבא מיד אחריה, כך ש-(int) Math.random() * 6 ממיר קודם את Math.random(). התוצאה תמיד 0, ו-0 * 6 הוא 0, כך שכל "הטלה" יוצאת זהה.

Math.random() מתאימה למשחקים ולתרגילים. לכל דבר מעבר לזה, המחלקה java.util.Random ו-ThreadLocalRandom.current().nextInt(min, max + 1) (ב-java.util.concurrent) מחזירות מספרים שלמים ישירות, ו-Random יכולה לקבל seed כדי לחזור על אותו רצף בבדיקות. אף אחת מהן לא מתאימה לסיסמאות או לטוקנים של אבטחה; לשם כך משתמשים ב-java.security.SecureRandom.

Math.PI ו-Math.E

Math.PI (π) ו-Math.E (המספר של אוילר, 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
    }
}

השתמשו בהם במקום להקליד 3.14. הם מדויקים ככל ש-double מאפשר, והשם אומר לקורא מה המספר.

תוצאות שלמות מול תוצאות double

רוב המתודות של Math מקבלות ומחזירות double. כשמעבירים להן ערכי int, Java מרחיבה את הארגומנטים ל-double אוטומטית, אבל החישוב שכותבים לפני הקריאה עדיין מתבצע ב-int. מכאן מגיעות רוב התשובות השגויות:

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

        System.out.println(Math.ceil(items / perBox));            // 3.0 (שגוי)
        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, וחלוקה של שני ערכי int משמיטה את השארית, כך שזה 3 עוד לפני ש-Math.ceil רואה את זה. Math.ceil(3.0) הוא 3.0. הפכו אחד מהאופרנדים ל-double, עם המרה או עם ליטרל כמו 4.0, כדי שהחלוקה תשמור על השבר. העמוד על אופרטורים מסביר חלוקת שלמים בפירוט רב יותר.

הכלל הכללי: מחליטים איזה טיפוס רוצים בסוף, דואגים שהחלוקה או הכפל יתבצעו ב-double כשהשברים חשובים, וממירים חזרה ל-int או ל-long רק פעם אחת, בסוף.

מתודות שימושיות נוספות

עוד כמה מתודות מאותה מחלקה, שכולן נקראות באותה צורה:

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 (לוגריתם טבעי)
        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 הוא הלוגריתם הטבעי; Math.log10 הוא בבסיס 10.
Math.floorMod(a, b) נותנת שארית עם הסימן של b, וזה מה שרוצים כשעוברים מסביב בטווח, כמו ימי השבוע. האופרטור % שומר על הסימן של a.
המתודות הטריגונומטריות (sin, cos, tan) מקבלות רדיאנים. ממירים מעלות עם Math.toRadians קודם.
Math.addExact, Math.multiplyExact והאחיות שלהן זורקות ArithmeticException בגלישה במקום לעבור בשקט למספר שלילי.

שאלות נפוצות

איך משתמשים ב-Math.pow ב-Java?

Math.pow(base, exponent) מחזירה את base בחזקת exponent בתור double, כך ש-Math.pow(2, 3) הוא 8.0. כדי לשמור את התוצאה ב-int, מבצעים המרה: int n = (int) Math.pow(2, 10); נותן 1024. ב-Java אין אופרטור חזקה ^; ^ הוא XOR ברמת הביטים.

איך יוצרים מספר אקראי בטווח עם Math.random?

Math.random() מחזירה double מ-0.0 ועד 1.0, לא כולל. למספר שלם מ-min עד max כולל, משתמשים ב-(int) (Math.random() * (max - min + 1)) + min. הטלת קובייה היא (int) (Math.random() * 6) + 1.

האם צריך לייבא את המחלקה Math ב-Java?

לא. Math נמצאת בחבילה java.lang, שכל קובץ Java מייבא אוטומטית. כל המתודות שלה הן static, ולכן קוראים להן על שם המחלקה, כמו Math.sqrt(16), בלי ליצור אובייקט.

למה Math.round מחזירה long ב-Java?

Math.round(double) מחזירה long כי double יכול להכיל ערכים גדולים בהרבה מ-int. השמת התוצאה ל-int דורשת המרה: int n = (int) Math.round(2.6);. Math.round(float) מחזירה int.

מה ההבדל בין Math.floor, Math.ceil ו-Math.round?

Math.floor מעגלת כלפי מטה (2.7 הופך ל-2.0, -2.3 הופך ל--3.0), Math.ceil מעגלת כלפי מעלה (2.1 הופך ל-3.0), ו-Math.round הולכת למספר השלם הקרוב ביותר, כשחצאים מתעגלים למעלה (2.5 הופך ל-3). floor ו-ceil מחזירות double; round מחזירה long.