streamalism.org

1. הקדמה

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

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

במאמר זה נתמקד בהמרות מסוג פרימיטיבי.

2. סקירה של פרימיטיבים

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

• בתים - 8 ביטים וחתומים

• קצר - 16 ביטים וחתומים

• לְהַשְׁחִיר - 16 ביטים ולא חתומים, כך שהוא עשוי לייצג תווי Unicode

• int - 32 ביטים וחתומים

• ארוך - 64 ביטים וחתומים

• לָצוּף - 32 ביטים וחתומים

• לְהַכפִּיל - 64 ביטים וחתומים

• בוליאני - זה לא מספרי, יכול להיות רק נָכוֹן אוֹ שֶׁקֶר ערכים

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

3. הרחבת המרות פרימיטיביות

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

int myInt = 127; ארוך myLong = myInt;

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

צף myFloat = myLong; כפול myDouble = myLong;

זה אפשרי מכיוון שהמעבר לפרימיטיבי רחב יותר לא מאבד שום מידע.

4. צמצום המרה פרימיטיבית

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

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

int myInt = (int) myDouble; בתים myByte = (בתים) myInt;

5. הרחבה וצמצום המרה פרימיטיבית

מצב זה קורה בא מקרה ספציפי מאוד כאשר אנו רוצים להמיר מ- בתים אל א לְהַשְׁחִיר. הגיור הראשון הוא הרחבת ה- בתים ל int ואז מה int הוא מצטמצם ל לְהַשְׁחִיר.

דוגמה תבהיר נקודה זו:

בתים myLargeValueByte = (בתים) 130; // 0b10000010 -126

הייצוג הבינארי של 130 זהה ל- -126, ההבדל הוא הפרשנות של ביט האות. בואו כעת להמיר מ בתים ל לְהַשְׁחִיר:

char myLargeValueChar = (char) myLargeValueByte; // 0b11111111 10000010 ערך לא חתום int myLargeValueInt = myLargeValueChar; // 0b11111111 10000010 65410

ה לְהַשְׁחִיר ייצוג הוא ערך Unicode, אך המרה ל- int הראה לנו ערך גדול מאוד שיש לו 8 סיביות נמוכות זהה לזה של -126.

אם נמיר אותו שוב ל- בתים אנחנו מקבלים:

בתים myOtherByte = (בתים) myLargeValueInt; // 0b10000010 -126

הערך המקורי בו השתמשנו. אם כל הקוד התחיל עם לְהַשְׁחִיר הערכים יהיו שונים:

char myLargeValueChar2 = 130; // זהו אינט לא בתים! // 0b 00000000 10000010 ערך לא חתום int myLargeValueInt2 = myLargeValueChar2; // 0b00000000 10000010 130 בתים myOtherByte2 = (בתים) myLargeValueInt2; // 0b10000010 -126

למרות ש בתים הייצוג זהה, שהוא -126, ה- לְהַשְׁחִיר ייצוג נותן לנו שתי דמויות שונות.

6. אגרוף / המרת Unboxing

בג'אווה יש לנו Class Wrapper לכל סוג פרימיטיבי, זוהי דרך חכמה לספק למתכנתים שיטות עיבוד שימושיות, ללא התקורה שיש הכל כהפניה של אובייקט כבד. מאז Java 1.5 נכללה היכולת להמיר אוטומטית מ / מ פרימיטיבי לאובייקט ובחזרה והושגה על ידי ייחוס פשוט:

Integer myIntegerReference = myInt; int myOtherInt = myIntegerReference;

7. המרות מיתרים

ניתן להמיר את כל הסוגים הפרימיטיביים חוּט באמצעות שיעורי העטיפה שלהם, העוקפים את toString () שיטה:

מחרוזת myString = myIntegerReference.toString ();

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

בתים myNewByte = Byte.parseByte (myString); קצר myNewShort = Short.parseShort (myString); int myNewInt = Integer.parseInt (myString); ארוך myNewLong = Long.parseLong (myString); צף myNewFloat = Float.parseFloat (myString); כפול myNewDouble = Double.parseDouble (myString); 

myNewBoolean בוליאני = בוליאני.parseBoolean (myString);

היוצא מן הכלל היחיד כאן הוא אופי כיתה כי א חוּט עשוי מ לְהַשְׁחִירבכל מקרה, בדרך זו, בהתחשב בכך שכנראה חוּט עשוי מסינגל לְהַשְׁחִיר, אנחנו יכולים להשתמש ב- charAt () שיטת ה- חוּט מעמד:

char myNewChar = myString.charAt (0);

8. מבצעים מספריים

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

יש קבוצה של כללים פשוטים החלים:

1. אם אחת האופרטות היא א לְהַכפִּיל, השני מקודם ל לְהַכפִּיל
2. אחרת, אם אחת האופרטות היא א לָצוּף, השני מקודם ל לָצוּף
3. אחרת, אם אחת האופרטות היא א ארוך, השני מקודם ל ארוך
4. אחרת, שניהם נחשבים int

בואו נראה דוגמה:

בתים op1 = 4; בתים op2 = 5; בתים myResultingByte = (בתים) (op1 + op2);

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

9. מסקנה

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

את הקוד המשמש במאמר זה ניתן למצוא באתר GitHub.