Java מציעה מחלקה מיוחדת של BigInteger לניהול מספרים גדולים במיוחד שגדולים ממספרי 64 סיביות. הגודל של ערכי המספרים השלמים שהמחלקה הזו יכולה להתמודד עם מוגבל פשוט על ידי הזיכרון המוקצה של ה-JVM. המחלקה BigInteger, שיורשת מספר.מיישמת את ממשק Comparable. זה נותן שווי ערך עבור כל אופרטור מספר שלם פרימיטיבי של Java, כמו גם לכל שיטה מהמודול java.lang.math. לא ניתן לשנות את הערך המאוחסן של אובייקט BigInteger בגלל חוסר השינוי של המחלקה BigInteger.
דוגמה 1:
התוכנית הבאה מספקת דרך ליצור את BigInteger ב-java ומחילה את הפעולה האריתמטית על הערך BigInteger שסופק.
ייבאנו את המחלקה BigInteger מחבילת ה-Java Math בתוך התוכנית. לאחר מכן, הכרזנו על האובייקטים BigInteger 'bigInt1' ו-'bigInt2' בשיטה main() של מחלקת ה-Java 'BigIntegerExample.' לאחר מכן, אתחלנו את האובייקטים BigInteger עם הערכים המספריים הגדולים בתוך המחלקה BigInteger. יצרנו אובייקט נוסף של המחלקה BigInteger לביצוע הפעולה האריתמטית על הערך השלם הגדול שצוין. האובייקטים מוכרזים כ'כפל' להכפלת הערך BinInteger ו'חלוקה' לחלוקת הערך BigInteger.
לאחר מכן, הקצינו את 'bigInt1' יחד עם שיטת multiply() של BigInteger לאובייקט 'כפיל', אשר לוקח את הקלט 'bigInt2.' כמו כן, קראנו למתודה division() אשר לוקחת את הפרמטר 'bigInt2' אשר יחולק עם 'bigInt1', ומדפיסה את התוצאות לאחר הביצוע.
תוצאות פעולת הכפל והחילוק על ערכי BigInteger מוצגות בתמונת הפלט הבאה. כך מוגדר ה-BigInteger ב-java ומשמש לפעולות שונות.
דוגמה 2:
חישוב פקטוריאלי הוא המחשה טובה למספר שלם שמקבל תשומות גדולות מאוד. ניתן גם להשתמש ב-BigInteger כדי לקבל את הפקטוריאלי עבור ערכי מספר שלם גדולים יותר.
יצרנו את הפונקציה 'פקטוריאלית' של המחלקה BigInteger, שבה האובייקט 'num' מסוג int מועבר כארגומנט להחזרת הפקטורי של הערך 'Num'. בתוך הפונקציה 'פקטוריאלית', הכרזנו על אובייקט BigInteger 'max_fict' שבו מצוין הערך BigInteger '2'. לאחר מכן, פרסנו את לולאת for, אשר תחזור על עצמה ולאחר מכן תכפיל את הערך 'max_fict' עם 4, 5, ועד הערך ה-n'י כאשר שיטת multiply() מופעלת. ה- multiply() עצמו נקרא שיטה נוספת של 'valueOf', שבה מסופק האובייקט 'i' של לולאת for. הצהרת ההחזר תספק את המפעל הגדול יותר. לאחר מכן, קבענו את השיטה main() של התוכנית. אתחלנו את האובייקט 'Num' עם הערך והדפיסנו את ה-Factory של ה-'Num' מתוך השיטה () factorial.
הערך הפקטוריאלי של המספר '40' מספק את הערך BigInteger באופן הבא:
דוגמה 3:
הפונקציה bitCount() של המחלקה BigInteger סופרת את הביטים. שיטת bitCount() מספקת את מספר הביטים שהם בצורה של שני משלים ב-BigInteger זה ושונים מסיבית הסימן. שיטה זו מחזירה את הביטים שנקבעו כאשר הערך של BigInteger חיובי. מצד שני, אם ה-BigInteger מצוין עם ערך שלילי, שיטה זו מחזירה את מספר סיביות האיפוס.
הכרזנו על שני משתנים, 'b1' ו-'b2' מסוג 'BigInteger'. הגדרנו גם שני משתנים נוספים, 'מספר שלם' ו-'מספר שלם', סוג אינט פרימיטיבי. בעקבות ההצהרה, אתחולנו את ה-'b1' עם הערך BigInteger החיובי ואת ה-'b2' עם הערך BigInteger השלילי. לאחר מכן, הקצינו את 'integer1' ו-'integer2' עם שיטת bitCount() למשתני BigInteger 'b1' ו-'b2.' הסיביות שנספרו יתקבלו מהשיטה bitCount() עבור ערכי BigInteger שצוינו.
ה-BigInteger החיובי מספק את '2' הסיביות, והערך השלילי של BigInteger מוציא את ערך הסיביות '1'.
דוגמה 4:
ניתן לקבוע את הערך המוחלט של נתונים מספריים בגודל גדול ב-BigInteger באמצעות שיטת abs() של המחלקה BigInteger. השיטה abs() מחזירה את הערך המוחלט של BigInteger.
יש לנו מחלקה BigInteger, שממנה הכרזנו על ארבעה משתנים: 'big1', 'big2', 'big3' ו-'big4'. המשתנים 'big1' ו-'big2' מצוינים עם ערכים חיוביים ושליליים, בהתאמה. לאחר מכן, הפעלנו את שיטת abs() עם 'big1' ו-'big2' במשתנים 'big3' ו-'big4'. שים לב ששיטת abs() אינה לוקחת שום ערך קלט אלא נקראת עם המשתנים 'big1' ו-'big2'. השיטה abs() מקבלת את הערך המוחלט עבור משתני BigInteger אלה, והתוצאות יודפסו בזמן ההידור.
הערך המוחלט של ערכי 432 חיוביים ושליליים של 432 זהה מכיוון ששיטת abs() מחזירה תמיד את הערך המוחלט החיובי.
דוגמה 5:
ניתן להשיג את ההשוואה של ערכי BigInteger באמצעות שיטת BigInteger compareTo() . ה-BigInteger מושווה ל-BigInteger שמוזן כפרמטר בתוך השיטה compareTo(). ערך ההחזרה של השיטה compareTo() מבוסס על ערכי BigInteger. כאשר ההשוואה של ערך BigInteger שווה, אז מוחזר אפס. אחרת, '1' ו-'-1' מוחזרים בתנאי שהערך BigInteger גדול או קטן מהערך BigInteger המועבר כארגומנט.
יש לנו אובייקטים 'MyBigInt1' ו-'MyBigtInt2' הצהרת המחלקה 'BigInteger.' אובייקטים אלה מצוינים לאחר מכן עם אותם ערכי BigInteger. לאחר מכן, יצרנו אובייקט נוסף, 'comparevalue' שבו האובייקט 'MyBigInt1' נקרא בשיטת compareTo() והאובייקט 'MyBigInt2' מועבר כארגומנט להשוואה עם האובייקט 'MyBigInt2'. לאחר מכן, יש לנו משפט if-else שבו בדקנו אם התוצאות של שיטת compareTo() שוות לערך '0' או לא.
מכיוון שלשני האובייקטים BigInteger יש אותם ערכים, התוצאות compareTo() מחזירות אפס, כפי שמוצג בתמונה למטה.
דוגמה 6:
ניתן להשתמש בשיטת BigInteger flipBit(index) גם כדי להפוך במיקום סיביות ספציפי בתוך BigInteger. שיטה זו מעריכה (bigInt ^ (1< מיקום האינדקס של הערך BigInteger '9' מתהפך עם האינדקס '2', שמוציא את הערך '13' בפלט. מחלקת BigInteger נוחה מאוד לשימוש ונמצאת בשימוש תדיר בתכנות תחרותי בשל ספריית המתודות העצומה שלה. ה-BigInteger משמש לחישוב של מספרים ארוכים מאוד החורגים מהיכולת של כל סוגי הנתונים הפרימיטיביים הנגישים כעת. הוא מספק שיטות שונות לפעולות אריתמטיות מודולריות. יצרנו תחילה את BigInteger ולאחר מכן כיסינו כמה מהשיטות שלו.
הגדרנו שני משתנים BigInteger, 'B_val1' ו-'B_val2.' המשתנה 'B_val1' מאותחל עם המחלקה BigInteger, כאשר הערך מצוין. לאחר מכן, הגדרנו את המשתנה 'B_val2' עם שיטת flipBit() כאשר פעולת flipBit מבוצעת על המשתנה 'B_value' עם ערך האינדקס '2'.
סיכום