מדריך לכיתה של Java Integer

במאמר זה נדבר על המחלקה Integer. בואו נשקול את השאלות האלה:

• מה הם שיעורי עטיפה;
• אריזה אוטומטית/פירוק של פרימיטיבים;
• פעולת המחלקה Integer, השיטות והקבועים שלה.

כיתות עטיפות מסוגים פרימיטיביים

כידוע, ל-Java יש סוגי נתונים שונים, אותם ניתן לחלק לשני בלוקים:

• פְּרִימִיטִיבִי;
• התייחסות.

ישנם מספר סוגי נתונים פרימיטיביים ב-Java:

• מספרים שלמים - בייט, קצר, int, ארוך;
• מספרי נקודה צפה (אמיתית) - צף, כפול;
• סוג נתונים לוגי - בוליאני;
• סוג נתוני תו - char.

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

המספר השלם

מחלקת Integer היא מחלקת עטיפה מהסוג הפרימיטיבי int. מחלקה זו מכילה שדה בודד מסוג int. כמחלקת עטיפה, Integer מספקת שיטות שונות לעבודה עם ints, וכן מספר שיטות להמרת int ל-String ו-String ל-int. להלן נבחן דוגמאות שונות לעבודה עם הכיתה. נתחיל ביצירה. האפשרות הנפוצה ביותר (והקלה ביותר לשימוש) היא אפשרות היצירה הבאה:

Integer a = 3;

כלומר, האתחול של משתנה Integer במקרה זה דומה לאתחול של משתנה int. יתר על כן, ניתן לאתחל משתנה שלם עם הערך של משתנה int:

int i = 5;
Integer x = i;
System.out.println(x); // 5

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

Integer x = new Integer(25);
System.out.println(x);

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

Integer a = null;
Integer b = a + 1; // Здесь мы упадем с "Exception in thread "main" java.lang.NullPointerException"
System.out.println(b);

רוב פעולות ההשוואה מבוצעות באותו אופן כמו בסוג הפרימיטיבי int:

Integer a = 1;
Integer b = 2;

System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);

תְפוּקָה:

false
false
true
true

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

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);

System.out.println(a == b); // true
System.out.println(a == c); // false

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

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a == b); // true
System.out.println(x == y); // false

כפי שאנו יכולים לראות, התוצאה של ההשוואה הראשונה נכונה, והתוצאה של השנייה היא שקרית. הכל עניין של שמירה במטמון. כל המספרים השלמים בטווח שבין -128 ל-127 כולל (ניתן להתאים אישית ערכים אלה) נשמרים במטמון. אז כשאנחנו יוצרים משתנה חדש ומקצים לו ערך של מספר שלם בין -128 ל-127, אנחנו לא יוצרים אובייקט חדש, אלא מקצה למשתנה הפניה לאובייקט שכבר נוצר במטמון. עכשיו, כשאני יודע את העובדה הזו, הדוגמה שלמעלה לא נראית כל כך מיסטית. משתנים a ו-b מתייחסים לאותו אובייקט - אובייקט מהמטמון. ובמהלך האתחול של המשתנים x ו-y, יצרנו אובייקט חדש בכל פעם, ומשתנים אלו שמנו הפניות לאובייקטים שונים. וכידוע, האופרטור == משווה את הערכים של משתנים, והערכים של משתני הייחוס הם הפניות. כדי לבדוק במדויק שוויון בין שני משתנים שלמים, עליך להשתמש (לא משנה כמה טריוויאלי זה נשמע) בשיטת שווה. נכתוב מחדש את הדוגמה למעלה:

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a.equals(b)); // true
System.out.println(x.equals(y)); // true

אריזה אוטומטית ופירוק מספר שלם

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

Integer a = 2020;

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

Integer a = 2020;
int x = a;

במקרה זה, נראה שהקצינו הפניה (כלומר, ההתייחסות לאובייקט היא הערך של המשתנה "a") למשתנה פרימיטיבי. אבל למעשה, הודות למנגנון ה-auto-unpacking, הערך 2020 נכתב למשתנה "x". אריזה/פריקה אוטומטית היא תופעה נפוצה מאוד ב-Java. לעתים קרובות זה קורה מעצמו, לפעמים אפילו ללא ידיעת המתכנת. אבל אתה עדיין צריך לדעת על התופעה הזו. יש לנו מאמר מעניין בנושא זה על Javarush .

קבועי מחלקה שלמים

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

public static void main(String[] args) {
        System.out.println(Integer.SIZE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.TYPE);
}

כתוצאה מכך, אנו מקבלים את הפלט הבא:

32
4
2147483647
-2147483648
int

שיטות של מחלקה שלמים

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

• 
  static int parseInt(String s)

שיטה זו ממירה מחרוזת ל-int. בואו נדגים איך שיטה זו עובדת:

int i = Integer.parseInt("10");
System.out.println(i); // 10

אם ההמרה אינה אפשרית - למשל, העברנו מילה לשיטת parseInt - תיזרק NumberFormatException. לשיטת parseInt(String s) יש אח עמוס מדי:

• 
  static int parseInt(String s, int radix)

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

System.out.println(Integer.parseInt("0011", 2)); // 3
System.out.println(Integer.parseInt("10", 8));   // 8
System.out.println(Integer.parseInt("F", 16));   // 15

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

• static Integer valueOf(int i) - מחזיר מספר שלם שהערך שלו הוא i;
• static Integer valueOf(String s) - דומה ל-parseInt(String s), אך התוצאה תהיה Integer;
• static Integer valueOf(String s, int radix) - דומה ל-parseInt(String s, int radix), אך התוצאה תהיה אינטגר.

דוגמאות:

int a = 5;
Integer x = Integer.valueOf(a);
Integer y = Integer.valueOf("20");
Integer z = Integer.valueOf("20", 8);

System.out.println(x); // 5
System.out.println(y); // 20
System.out.println(z); // 16

בדקנו שיטות המאפשרות לך להמיר מחרוזת ל-int/integer. ההליך ההפוך מושג באמצעות שיטות toString . אתה יכול לקרוא למתודה toString על כל אובייקט Integer ולקבל את ייצוג המחרוזת שלו:

Integer x = 5;
System.out.println(x.toString()); // 5

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

System.out.println(Integer.toString(5)); // 5

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

• static String toString(int i, int radix) - ימיר את i לייצוג מחרוזת במערכת המספרים של הרדיוס.

דוגמא:

System.out.println(Integer.toString(5, 2)); // 101

למחלקה Integer יש כמה שיטות למציאת המקסימום/מינימום של שני מספרים:

• static int max(int ​​a, int b) יחזיר את הערך הגדול ביותר מבין המשתנים שעברו;
• static int min(int a, int b) יחזיר את הערך הקטן ביותר מבין המשתנים שעברו.

דוגמאות:

int x = 4;
int y = 40;

System.out.println(Integer.max(x,y)); // 40
System.out.println(Integer.min(x,y)); // 4

סיכום

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

שיעורי בית

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

   נ.ב אין כאן תשובות נכונות, אבל פעילות זו תאפשר לך ללמוד טוב יותר את הכיתה.

2. פתור בעיה קטנה ופשוטה כדי לגבש את החומר.

   יש לנו שני מספרים:

   1100001001 - במערכת המספרים הבינארית
   33332 - במערכת המספרים הקווינרית

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

3. המר את הערך השלם המקסימלי האפשרי למערכת המספרים האוקטליים והצג את מספר הספרות במספר המתקבל (ספור את המספר באופן תוכנתי).