Java Float מילת מפתח

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

מספרים עשרוניים. כיצד מאוחסנים מספרים אמיתיים במחשב?

כדי לאחסן מספרים ממשיים בזיכרון המחשב, מוקצים מספר מסוים של סיביות. מספר ממשי מאוחסן כסימן (פלוס או מינוס), גמל שלמה ומעריך. מהי המנטיסה והמעריך עדיף להסביר בעזרת דוגמה. המסה המשוערת של הירח היא 7* 1022. כאן 7 הוא הגמל שלמה, ב-22 המעריך. כאשר מציגים מספרים גדולים או להיפך, קטנים מאוד על המסך, ניתן לראות ערך כמו 7E22. זהו מספר הנקודה הצפה, ו-7 כאן הוא הגמל, ו-22 הוא המעריך או החזקה של 10. סימון זה נקרא סימון מעריכי.

Java Float מילת מפתח ומילת מפתח כפולה Java

ערכי צף (מספרי נקודה צפה או מספרים ממשיים) ב-Java מיוצגים על ידי הסוגים float ו- double . מילות המפתח הללו משמשות לאחסון ערכים עד לסימן מסוים אחרי הנקודה העשרונית. כפול הם מספרים עם דיוק כפול, קרוב ככל האפשר לערכים שניתנו או מתקבלים כתוצאה מחישובים. Java Double משמש עבור כל חישוב מתמטי (שורש ריבוע, סינוס, קוסינוס, ..), כמו גם עבור כל החישובים שבהם דיוק מסוים חשוב. סוג נתונים צף משמש לסוג פחות מדויק של נקודה צפה. הוא משמש לעתים רחוקות מאוד כדי לחסוך בזיכרון. כאן למטה יש לנו טבלה עם המידע העיקרי על ציפה וכפול, כמו גם ההבדלים ביניהם. אז מילת מפתח Float פירושה מספר, ערך דיוק יחיד שלוקח 32 ביטים או 4 בתים בזיכרון. במעבדים מסוימים, העבודה עם מספרים כאלה מהירה יותר, וכפי שכבר הוזכר, הם תופסים פחות מקום בהשוואה למספרים עם דיוק כפול. עם זאת, אי אפשר לומר חד משמעית במהירות. נניח שחלק מהמעבדים המודרניים מעבדים מספרים מדויקים כפולים מהר יותר.

Java Float והצהרה כפולה

אתה יכול להכריז על מספר סוג כפול באותו אופן כמו מספרים מסוגים אחרים:

double myDouble = 2.7;

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

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14;
   }
}

זה מה שקורה אם אתה מפעיל את התוכנית הזו:

Error:(4, 25) java: incompatible types: possible lossy conversion from double to float

העובדה היא שלא רצוי להשתמש במספרי צפים, וזה צריך להיעשות רק כדי לחסוך בזיכרון. כל המספרים השברים האמיתיים ב-Java הם Double כברירת מחדל, וגם התחביר של השפה מדגיש זאת. אם אתה באמת רוצה לעבוד עם סוג הצף, אתה צריך לציין אותו במפורש עם f שמסיים את המספר.

public class FloatExample {
   public static void main(String[] args) {
//double and float variables
       double myDouble = 2.7;
       float myFloat = 3.14f;
   }
}

אגב, ניתן לכתוב מספרים צפים וכפולים בצורה אקספוננציאלית.

float myFloat2 = 2E22f;
double myDouble2 = 3e10;

אם אתה משתמש במספרים גדולים מספיק בייצוג ה"רגיל" שלהם, Java תציג אותם מיד בצורה אקספוננציאלית. בוא נביא דוגמה:

public class FloatExample {
   public static void main(String[] args) {
//float variables
               float myFloatNumber1=2182818284590.45f;
               float myFloatNumber2=19822612787260.141592181f;
               System.out.println("myFloatNumber1 = " + myFloatNumber1);
               System.out.println("myFloatNumber2 = " + myFloatNumber2);
       System.out.println("myFloatNumber1 + myFloatNumber2 = " + myFloatNumber1 + myFloatNumber2);
           }
       }

התוצאה של עבודת התוכנית הזו נמצאת כאן:

דוגמה מיוחדת לצוף ומספרים כפולים

ישנם שלושה מספרי נקודה צפה מיוחדים בשפת Java, המשמשים לציון הצפות ושגיאות. הנה הם:

• אינסוף חיובי הוא תוצאה של חלוקת מספר חיובי ב-0. מיוצג על ידי הקבועים Double.POSITIVE_INFINITY ו- Float.POSITIVE_INFINITY .

• אינסוף שלילי הוא תוצאה של חלוקת מספר שלילי ב-0. מיוצג על ידי הקבועים Double.NEGATIVE_INFINITY ו- Float.NEGATIVE_INFINITY .

• NaN (לא מספר) מייצג את החישוב של 0/0 או לקיחת השורש הריבועי של מספר שלילי. מיוצג על ידי הקבועים Double.NaN ו- Float.NAN .

הנה דוגמה לשימוש במספרי הנקודה הצפה המיוחדת:

public class FloatExample {
   public static void main(String[] args) {
       int myInt = 1;
       float zero = 0.0f;
       double negZero = -0.0;
       double negativeInfinity = Double.NEGATIVE_INFINITY;
       double positiveInfinity = Float.POSITIVE_INFINITY;

       System.out.println(myInt / zero);
       System.out.println(myInt / negZero);
       System.out.println(zero == negZero);
       System.out.println(negativeInfinity * 0);
       System.out.println(positiveInfinity+negativeInfinity);

   }
}

התוצאה היא:

האם דיוק כפול מספיק?

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

public class FloatExample {
   public static void main(String[] args) {
       System.out. println( "2.0 - 1.1 = " + (2.0 - 1.1));
   }
}

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