עיגול מספרים ב-Java

מספרי נקודה צפה (צף, כפול) משמשים בעת חישוב ביטויים הדורשים דיוק עשרוני. לרוב יש צורך בדיוק גבוה בפעולות חשבונאיות ופעולות מחשוב אחרות. אבל האם אנחנו צריכים תמיד "זנב" ארוך של מספרים אחרי הנקודה העשרונית? אולי מספיק לנו דיוק של שלושה חלקים אמיתיים? ואנחנו מרוצים מהאפשרות הזו, איך נכון לבצע עיגול? על זה בדיוק נדבר היום: נבחן דרכים לעגל מספרים ב-Java .

פורמט מחרוזת

כשיטה ראשונה, נסתכל על עיגול כפול:

double value = 34.766674;
String result = String.format("%.3f",value);
System.out.print(result);//  34,767

כתוצאה מכך, אנו נעצב את מספר הנקודה הצפה שלנו 34766674 בדיוק של 3 מקומות עשרוניים , שכן בהוראות העיצוב ציינו שלושה מקומות עשרוניים "%.3f. בתורו, %f בעת עיצוב מחרוזת מציין את סוג הנקודה הצפה. מספרים, הכוללים את סוג הנתונים double and float ב-Java. בדוגמה למעלה, אנו פלט את הערך המתקבל לקונסולה. כעת השאלה היא: איך נוכל לקצר את זה? זה פשוט: אתה צריך להשתמש ב-printf, שבתורו הוא פורמט + הדפסה. כתוצאה מכך, הדוגמה הקודמת שלנו תצטמצם ל:

double value = 34.766674;
System.out.printf("%.3f",value);

בנוסף לשיטה זו , למופע ה-out של המחלקה PrintStream יש גם שיטת פורמט, הפועלת באופן דומה:

double value = 34.766674;
System.out.format("%.3f",value);

העיגול מתרחש במצב HALF_UP - לכיוון המספר הקרוב יותר לחתוך (ל-0 או 10). אם המספרים הללו נמצאים במרחק שווה (במקרה של 5), אזי מתבצע עיגול כלפי מעלה. דוגמא:

String firstResult = String.format("%.3f",7.0004);// 7,000
String secondResult = String.format("%.3f",7.0005);// 7,001
String thirdResult = String.format("%.3f",7.0006);// 7,001

נדון במצבי עיגול ביתר פירוט בהמשך.

DecimalFormat

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

double value = 34.766674;
DecimalFormat decimalFormat = new DecimalFormat( "#.###" );
String result = decimalFormat.format(value);
System.out.print(result);//34,767

השורה #.### היא תבנית המציינת שאנו מעצבים את הערך המועבר ל-3 מקומות עשרוניים. כדי לשנות את התבנית לאחר יצירת האובייקט DecimalFormat, אתה יכול להשתמש בשיטות applicationPattern ו- applycalizedPattern שלו :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
decimalFormat.applyPattern("#.#");
decimalFormat.applyLocalizedPattern("#.#####");

אבל היום אנחנו מדברים על עיגול, לא? כאשר חותכים מספר עם מקומות עשרוניים מעבר לתבנית שצוינה, DecimalFormat מעגל את המספר כלפי מעלה אם המספר הקטוע האחרון גדול מ-5. אבל מה אם המספר הוא 5? מסתבר שזה בדיוק באמצע בין המספרים השלמים הקרובים ביותר. מה אז? במקרה זה, המספר הקודם נלקח בחשבון. אם זה זוגי, העיגול מתבצע:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4565);
System.out.println((result));// 7,457

אם מוזר, זה לא מבוצע:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4575);
System.out.println((result));// 7,457

יש הבדל קל בין עיצוב מספרי נקודה צפה באמצעות String.format() ו-DecimalFormat.format(). הראשון תמיד ידפיס אפסים נגררים גם אם אין חלק חלקי. לְמָשָׁל:

String firstResult = String.format("%.3f", 7.000132);
System.out.println((firstResult)); // 7.000

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String secondResult = decimalFormat.format(7.000132);
System.out.println((secondResult));  // 7

כפי שאנו יכולים לראות, בעת עיצוב המספר 7.000132 לשלושה מקומות עשרוניים, שיטת ה-format() של String תוציא 7.000, בעוד ששיטת ה-format() של DecimalFormat תוציא 7. כלומר, ניתן לבחור String.format() או DecimalFormat. format( ) תלוי אם אתה צריך אפסים נגררים או לא. באמצעות השיטות שתוארו לעיל, קיבלנו את התוצאה בצורה של מחרוזת. בואו נסתכל על דרכים להחזיר בדיוק את הערכים המספריים.

מתמטיקה

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

• Math.ceil() מעגלת למעלה למספר השלם הקרוב ביותר, אך מחזירה לא סוג מספר שלם, אלא כפול:

  double value = 34.777774;
  double result = Math.ceil(value);
  System.out.println((result)); //35.0

  גם אם יש לנו 34.0000000, לאחר השימוש ב- Math.ceil עדיין נקבל 35.0.

  Math.floor() מתעגל כלפי מטה למספר השלם הקרוב ביותר, ומחזיר גם את התוצאה כפולה:

  double value = 34.777774;
  double result = Math.floor(value);
  System.out.println((result)); //34.0

  שוב, גם אם יש לנו ערך של 34.999999999, אז לאחר השימוש ב- Math.floor נקבל 34.0.

• Math.round () - מעגל למספר השלם הקרוב ביותר, נותן את התוצאה int:

  double value = 34.777774;
  int result = Math.round(value);
  System.out.println((result)); //35

  אם המספר שלנו הוא 34.5, הוא מעוגל ל-35, אבל אם הוא מעט פחות מ-34.499, המספר נחתך ל-34.

  כדי לא פשוט לחתוך את כל החלק הממשי, אלא לווסת את התהליך הזה למספר מסוים של מקומות עשרוניים ובו-זמנית לעגל, המספר מוכפל ב-10^n (10 בחזקת n), כאשר n שווה למספר המקומות העשרוניים הדרושים. לאחר מכן, נעשה שימוש בשיטה כלשהי של המחלקה Math לעגל, ואז שוב לחלק ב-10^n:

  double value = 34.777774;
  double scale = Math.pow(10, 3);
  double result = Math.ceil(value * scale) / scale;
  System.out.println((result)); //34.778

  Math.pow - לוקח שני ארגומנטים. הראשון הוא המספר, השני הוא העוצמה שאליו צריך להעלות אותו.

עיגול עם BigDecimal

BigDecimal היא מחלקה המאפשרת לך לעבוד עם מספרי נקודה צפה. במיוחד, התכונה העיקרית שלו היא שהוא יכול לאחסן מספרים שברים באורך שרירותי (כלומר, אין הגבלה על טווח המספר). בנוסף, מחלקה זו מאחסנת שיטות שונות לעיבוד אריתמטי, כולל עיגול. ניתן ליצור את המחלקה של אובייקט זה על ידי הגדרת הבנאי ככפול, מחרוזת להצגת מספר נקודה צפה, כפולה ו- MathContext וכן הלאה. MathContext הוא שילוב של RoundingMode ומספר שמתאר את המספר הכולל של הספרות בערך המבוקש. כללי עיגול RoundingMode: DOWN - עיגול לכיוון אפס. למעלה - עיגול ממצב אפס. CEILING - עיגול לכיוון אינסוף חיובי. FLOOR - עיגול לכיוון אינסוף שלילי. HALF_UP - מעגל ל"השכן הקרוב ביותר" אם שני השכנים אינם במרחק שווה (כלומר, כאשר המספר שמתעגל הוא 5). במקרה זה, מתבצע עיגול כלפי מעלה. HALF_DOWN - עיגול לכיוון "השכן הקרוב". אם שני השכנים אינם במרחק שווה, במקרה זה יש לעגל למטה. HALF_EVEN - סיבוב ל"שכן הקרוב" אם שני השכנים אינם במרחק שווה. במקרה זה, עגל לשכן הזוגי (כמו ב-DecimalFormat שתואר לעיל). מיותר - משמש לאישור שלפעולה המבוקשת יש את התוצאה הנכונה. לכן, אין צורך לעגל. דוגמא:

MathContext context = new MathContext(5, RoundingMode.HALF_UP);
double value = 34.777554;
BigDecimal result = new BigDecimal(value, context);
System.out.println(result); //34.778

בנוסף ליכולת להגדיר כלל עיגול בקונסטרוקטור, BigDecimal מאפשר לך להגדיר את מצב העיגול לאחר יצירת המופע. לשם כך, השתמש בשיטת setScale , שבה עליך להגדיר את מספר המקומות העשרוניים וכללי עיגול:

double value = 34.777554;
BigDecimal result = new BigDecimal(value);
result = result.setScale(3, RoundingMode.DOWN);
System.out.println(result); //34.777

ל-BigDecimal יש גם משתני int פנימיים שנועדו להגדיר את מצב העיגול ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR ...) אלו כללי עיגול דומים לאלו המוצגים במחלקה RoundingMode ומשמשים באופן דומה ב- setScale :

BigDecimal result = new BigDecimal(value);
result = result.setScale(3, BigDecimal.ROUND_DOWN);

קרא עוד על המחלקה BigDecimal במאמר זה .