Java BigInteger Class

מה זה מחלקה של שלם גדול?

ישנם כמה סוגי נתונים פרימיטיביים ב-Java המשמשים, כגון int או long, לביצוע פעולות שלמים. עם זאת, לפעמים אנחנו צריכים לאחסן מספרים גדולים מחוץ לתחום של סוגי נתונים פרימיטיביים כאלה. BigInteger Class משמש לחישובים מתמטיים עבור מספרים גדולים מאוד. הוא מספק את כל השיטות מחבילת java.lang.Math ואנלוגים לכל האופרטורים השלמים הפרימיטיביים של Java. BigInteger Class מכסה פעולות עבור אריתמטיקה מודולרית, מניפולציה של סיביות, חישוב GCD ועוד כמה פעולות. BigIntegers מיוצגים בסימון משלים של שניים. אין הגבלה תיאורטית על כמה גדול ניתן לאחסן מספר מכיוון שהזיכרון מוקצה באופן דינמי. עם זאת, למעשה הזיכרון מוגבל ונוכל לאחסן מספר שלם שמספר הביטים קטן או שווה למספר השלם.MAX_VALUE . זה מספק גבול עליון גדול מספיק כדי לאחסן כמעט את כל המספרים הגדולים.

כיצד מיושמת מחלקת BigInteger?

import java.math.BigInteger;

כדי ליישם את המחלקה BigInteger בקוד שלך, עליך לייבא את חבילת java.math.BigInteger .

הצהרת מחלקה BigInteger

המחלקה BigInteger ב-Java מוצהרת באופן הבא בחבילת java.math :

public class BigInteger
   extends Number
      implements Comparable<BigInteger>

המחלקה BigInteger מרחיבה את המחלקה Number ומטמיעה ממשק Comparable . זה מוצהר ומוגדר בחבילת java.math .

בוני כיתות

למחלקת BigInteger של Java יש הרבה בנאים עמוסים מדי. אתה יכול לנסות ולהריץ כל אחד מהם בעורך כדי לראות איך הם עובדים.

שיטות כיתה

למחלקה BigInteger של Java יש שיטות רבות, חלקן מתוארות להלן. בטבלה, 'זה' מייצג את ה- BigInteger שקורא למתודה ו-' val ' הוא הארגומנט המועבר למתודה.

דוגמה 1

import java.math.BigInteger;
public class Example1 {
    static BigInteger calculateFactorial(int val) {
        // Initialize result
        BigInteger f = BigInteger.ONE; // Or new BigInteger("1")
        // compute factorial
        for (int i = 2; i <= val; i++) {
            f = f.multiply(BigInteger.valueOf(i));
        }

        return f;
    }

    // Driver method
    public static void main(String[] args) {
        int val = 25;
        System.out.println(calculateFactorial(val));
    }
}

תְפוּקָה

הֶסבֵּר

בקטע שלמעלה, הגורם של מספר גדול מחושב באמצעות BigInteger Class על ידי ייבוא ​​חבילת java.math.BigInteger . יצרנו שיטת calculateFactorial . שיטה זו יוצרת BigInteger ולאחר מכן מחשבת את הפקטוראלי באמצעות שיטת הכפל f.multiply(BigInteger.valueOf(i)) .

דוגמה 2

import java.math.BigInteger;
public class Example2 {

    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("20");
        BigInteger big2 = new BigInteger("60");
        BigInteger sub = big2.subtract(big1);
        System.out.println(big2 + " - " + big1 + " = " + sub);
        BigInteger add = big1.add(big2);
        System.out.println(big1 + " + " + big2 + " = " + add);
        BigInteger mul = big1.multiply(big2);
        System.out.println(big1 + " * " + big2 + " = " + mul);
        BigInteger div = big2.divide(big1);
        System.out.println(big2 + " / " + big1 + " = " + div);
        BigInteger min = big1.min(big2);
        System.out.println("min value: " + min);
        BigInteger max = big1.max(big2);
        System.out.println("max value: " + max);
    }
}

תְפוּקָה

הֶסבֵּר

בקטע שלמעלה, יצרנו שני BigInteger באמצעות הבנאי BigInteger(String val) . יישמנו שיטות שונות על big1 ו- big2 של BigInteger עם הערכים 20 ו-60 בהתאמה. יישמנו את השיטות הבאות:

1. big2.subtract(big1) כדי להחסיר 20 מ-60.
2. big1.add(big2) כדי להוסיף 20 ו-60.
3. big1.multiply(big2) כדי להכפיל 20 ו-60.
4. big2.divide(big1) כדי לחלק 60 ב-20.
5. big1.min(big2) כדי לקבל את הקטן מבין שני הערכים.
6. big1.max(big2) כדי לקבל את הגדול מבין שני הערכים.

חשוב לציין ש- java.math.BigInteger מיובא בחלק העליון של הקוד.

סיכום

עד עכשיו אתה אמור להכיר את מחלקת BigInteger ב-Java. אתה אמור להיות מסוגל להשתמש ב-BigInteger s בקוד שלך באמצעות סוגים שונים של בנאים. כמו כן, אתה אמור להיות מסוגל לבצע עליהם פעולות אריתמטיות והגיוניות שונות באמצעות שיטות BigInteger Class. כאתגר, אתה יכול לנסות לקרוא לשיטות שונות עם ערכים שונים של BigInteger s. זה יחזק עוד יותר את ההבנה שלך של BigInteger s ב-Java. כדי להיות בטוח יותר בלמידה שלך נסה לתרגל אותה שוב ושוב. המפתח לקידוד טוב הוא תרגול. בהצלחה וקידוד שמח!