streamalism.org

1. סקירה כללית

שפת התכנות של Java כוללת שמונה סוגי נתונים פרימיטיביים.

במאמר זה נזכור מה הם פרימיטיבים ונעבור עליהם.

2. סוגי נתונים פרימיטיביים

שמונת הפרימיטיבים המוגדרים ב- Java הם int, בתים, קצר, ארוך, לָצוּף, לְהַכפִּיל, בוליאני, ו char - אלה אינם נחשבים לאובייקטים ומייצגים ערכים גולמיים.

הם מאוחסנים ישירות על הערימה (עיין במאמר זה למידע נוסף על ניהול זיכרון ב- Java).

בואו נסתכל על גודל האחסון, על ערכי ברירת המחדל ועל דוגמאות לשימוש בכל סוג.

נתחיל בהתייחסות מהירה:

2.1. int

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

במיוחד, ג'אווה מאחסנת אותו באמצעות 32 סיביות של זיכרון. במילים אחרות, הוא יכול לייצג ערכים מ -2,147,483,648 (-231) ל -2,147,483,647 (231-1).

ב- Java 8 ניתן לאחסן ערך שלם לא חתום עד 4,294,967,295 (232-1) באמצעות פונקציות עוזרות מיוחדות חדשות.

אנחנו יכולים פשוט להכריז על int בפשטות:

int x = 424_242; int y;

ערך ברירת המחדל של int הוכרז ללא מטלה הוא 0.

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

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

2.2. בתים

בתים הוא סוג נתונים פרימיטיבי הדומה ל- int, מלבד זה תופס רק 8 סיביות של זיכרון. לפיכך, מדוע אנו קוראים לזה בתים. מכיוון שגודל הזיכרון כל כך קטן, בתים יכול להחזיק את הערכים רק מ -128 (-27) עד 127 (27 - 1).

אנחנו יכולים ליצור בתים:

בתים b = 100; בתים ריקים;

ערך ברירת המחדל של בתים הוא גם 0.

2.3. קצר

התחנה הבאה ברשימת סוגי הנתונים הפרימיטיביים שלנו ב- Java היא קצר.

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

עם 16 סיביות של זיכרון, זה חצי מגודל int וגודל כפול מ בתים. טווח הערכים האפשריים שלו הוא -32,768 (-215) עד 32,767 (215 - 1).

קצר מוכרז כך:

קצר s = 202_020; קצר s;

בדומה גם לסוגים האחרים, ערך ברירת המחדל הוא 0. אנו יכולים להשתמש בכל החשבון הסטנדרטי גם עליו.

2.4. ארוך

סוג הנתונים הפרימיטיבי האחרון שלנו הקשור למספרים שלמים הוא ארוך.

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

הערכים האפשריים של ארוך הם בין -9,223,372,036,854,775,808 (-263) ל- 9,223,372,036,854,775,807 (263 - 1).

אנחנו יכולים פשוט להכריז על אחד:

ארוך l = 1_234_567_890; ארוך l;

כמו בסוגים שלמים אחרים, ברירת המחדל היא גם 0. אנו יכולים להשתמש בכל חשבון on ארוך שעובד על int.

2.5. לָצוּף

אנו מייצגים מספרים חלקיים בסיסיים בג'אווה באמצעות ה- לָצוּף סוּג. זהו מספר עשרוני בעל דיוק יחיד. מה שאומר שאם נחלוף על שש נקודות עשרוניות, המספר הזה נעשה פחות מדויק ויותר אומדן.

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

סוג זה נשמר ב- 32 סיביות של זיכרון בדיוק כמו int. עם זאת, בגלל הנקודה העשרונית הצפה הטווח שלה שונה בהרבה. זה יכול לייצג מספרים חיוביים ושליליים כאחד. העשרון הקטן ביותר הוא 1.40239846 x 10-45, והערך הגדול ביותר הוא 3.40282347 x 1038.

אנו מצהירים לָצוּףזהה לכל סוג אחר:

לצוף f = 3.145f; לצוף f;

וערך ברירת המחדל הוא 0.0 במקום 0. כמו כן, שימו לב שאנחנו מוסיפים את f ייעוד לסוף המספר המילולי להגדרת צף. אחרת, Java תזרוק שגיאה מכיוון שסוג ברירת המחדל של ערך עשרוני הוא לְהַכפִּיל.

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

2.6. לְהַכפִּיל

לאחר מכן, אנו מסתכלים על לְהַכפִּיל - שמו מגיע מכך שמדובר במספר עשרוני כפול.

הוא מאוחסן ב -64 סיביות של זיכרון. מה שאומר שהוא מייצג מגוון גדול בהרבה של מספרים אפשריים מ- לָצוּף.

אמנם, הוא אכן סובל מאותה מגבלת דיוק כמו לָצוּף עושה. הטווח הוא 4.9406564584124654 x 10-324 עד 1.7976931348623157 x 10308. טווח זה יכול להיות גם חיובי או שלילי.

מכריז לְהַכפִּיל זהה לסוגים מספריים אחרים:

כפול d = 3.13457599923384753929348D; כפול ד;

ערך ברירת המחדל הוא גם 0.0 כמו שהוא לָצוּף.דומה ל לָצוּף, אנו מצרפים את המכתב ד לייעד את המילולי ככפול.

2.7. בוליאני

סוג הנתונים הפרימיטיבי הפשוט ביותר הוא בוליאני. הוא יכול להכיל שני ערכים בלבד: נָכוֹן אוֹ שֶׁקֶר. הוא שומר את ערכו בסיבית בודדת.

עם זאת, מטעמי נוחות, ג'אווה מרפדת את הערך ומאחסנת אותו בבת אחת.

לְהַכרִיז בוליאני ככה:

בוליאני b = נכון; בוליאני b;

הכרזה עליו ללא ערך ברירת מחדל ל שֶׁקֶר. בוליאני היא אבן הפינה לשליטה בזרימת התוכניות שלנו. אנו יכולים להשתמש במפעילים בוליאניים עליהם (כלומר, וגם, או, וכו.).

2.8. לְהַשְׁחִיר

סוג הנתונים הפרימיטיבי הסופי שיש להסתכל עליו הוא לְהַשְׁחִיר.

נקרא גם דמות, לְהַשְׁחִיר הוא מספר שלם של 16 סיביות המייצג תו המקודד ל- Unicode. הטווח שלה הוא בין 0 ל -65,535. אשר ב- Unicode מייצג '\ U0000' ל '\ Uffff'.

לקבלת רשימה של כל ערכי Unicode האפשריים בדוק אתרים כמו Unicode Table.

בואו נכריז כעת על לְהַשְׁחִיר:

char c = 'a'; char c = 65; char c;

כאשר אנו מגדירים את המשתנים שלנו, אנו יכולים להשתמש בכל תו תרתי, והם יהפכו אוטומטית לקידוד ה- Unicode שלהם עבורנו. ערך ברירת מחדל של תווים הוא '/ U0000'.

2.9. הצפה

לסוגי הנתונים הפרימיטיביים יש מגבלות גודל. אבל מה קורה אם ננסה לאחסן ערך גדול מהערך המרבי?

אנו נקלעים למצב שנקרא הצפה.

כאשר מספר שלם עולה על גדותיו, הוא מתגלגל לערך המינימלי ומתחיל לספור משם.

הצפת מספר הנקודה הצפה על ידי החזרת האינסוף. כאשר הם זורמים, הם מחזירים 0.0.

הנה דוגמה:

int i = Integer.MAX_VALUE; int j = i + 1; // j יעבור ל -2_147_483_648 כפול d = Double.MAX_VALUE; כפול o = d + 1; // o יהיה אינסוף

תת-זרימה היא אותה בעיה למעט אם אנו שומרים ערך קטן מהערך המינימלי.

2.10. תיבה אוטומטית

לכל סוג נתונים פרימיטיבי יש גם יישום מלא של מחלקת Java שיכול לעטוף אותו. למשל, ה מספר שלם בכיתה יכולה לעטוף int. לעיתים יש צורך להמיר מהסוג הפרימיטיבי לעטיפת האובייקטים שלו (למשל, להשתמש בהם עם גנריות).

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

דמות c = 'c'; שלם i = 1;

3. מסקנה

במדריך זה סקרנו את שמונה סוגי הנתונים הפרימיטיביים הנתמכים בג'אווה.

אלה אבני הבניין המשמשות את רובם, ולא את כל תוכניות הגאווה שם - ולכן כדאי להבין כיצד הן פועלות.