משהו על מערכים בג'אווה

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

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10]; // array of Java strings

   }
}

כאן יצרנו מערך של 10 תאים. אתה יכול לשים לב מיד לכמה תכונות של המערך:

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

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

//Java arrays of strings, two syntaxes
String [] birthdays = new String[10];
String birthdays [] = new String[10];

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
   }
}

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[7] = "Olesya Ostapenko, January 3";
   }
}

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[7] = "Olesya Ostapenko, January 3";

       String olesyaBirthday = birthdays[7];
       System.out.println(olesyaBirthday);
   }
}

פלט מסוף:

Олеся Остапенко, 3 января

יצרנו משתנה Stringואמרנו למהדר: "מצא את התא עם אינדקס 7 במערך birthdaysוהקצה את הערך המאוחסן שם למשתנה String olesyaBirthday." זה בדיוק מה שהוא עשה.

אורך מערך Java

בעבודה עם מערך, ניתן לגלות בקלות את אורכו באמצעות תכונה מיוחדת - length.

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[7] = "Olesya Ostapenko, January 3";

       int birthdaysLength = birthdays.length;
       System.out.println(birthdaysLength);
   }
}

פלט מסוף:

10

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Lena Eliseeva, March 12";
       birthdays[1] = "Kolya Romanov, May 18";
       birthdays[2] = "Vika Ignatova, July 12";
       birthdays[3] = "Denis Kozlov, September 7";
       birthdays[4] = "Maxim Maslennikov, November 9";
       birthdays[5] = "Roman Baranov, August 14";
       birthdays[6] = "Valery Pyatkina, April 1";
       birthdays[7] = "Olesya Ostapenko, January 3";
       birthdays[8] = "Kostya Gurko, October 19";
       birthdays[9] = "Seryozha Naumov, May 3";

       for (int i = 0; i < birthdays.length; i++) {
           System.out.println(birthdays[i]);
       }
   }
}

בלולאה אנו יוצרים משתנה iששווה בהתחלה לאפס. בכל מעבר, אנחנו לוקחים את התא עם index i מהמערך שלנו ומדפיסים את הערך שלו לקונסולה. הלולאה תבצע 10 איטרציות, והערכים של i יגדלו מ-0 ל-9 - רק לפי המדדים של התאים של המערך שלנו! כך נדפיס את כל הערכים מ- birthdays[0]ועד לקונסולה birthdays[9] , למעשה, יש דרכים ליצור מערך בצורה שונה. לדוגמה, intניתן ליצור מערך של מספרים כך:

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
   }
}

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

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
       System.out.println(numbers.length);
   }
}

פלט מסוף:

9

מערך אובייקטים של Java

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

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Hippopotamus");
       cats[2] = new Cat("Philip Markovich");
   }
}

יש כמה דברים שצריך להבין כאן:

1. במקרה של פרימיטיבים, מערכי Java מאחסנים ערכים ספציפיים רבים (כגון מספרים int). במקרה של אובייקטים, מערך מאחסן הפניות רבות. המערך catsמורכב משלושה תאים, שכל אחד מהם מכיל הפניה לאובייקט Cat. כל אחד מהקישורים מצביע על כתובת בזיכרון שבה מאוחסן אותו אובייקט.
2. רכיבי מערך מאוחסנים בזיכרון בבלוק בודד. זה נעשה עבור גישה יעילה ומהירה יותר אליהם. לפיכך, הקישור catsמצביע על בלוק בזיכרון שבו מאוחסנים כל האובייקטים - רכיבי המערך. A cats[0]- לכתובת ספציפית בתוך בלוק זה.

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

מערך מערכים או מערך דו מימדי

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

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
}

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

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
   cats[1][2] = new Cat("Fluff");
}

[1]מצביע על המערך השני, [2]ומצביע על התא השלישי של המערך הזה. מכיוון שמערך דו מימדי מורכב ממספר מערכים, על מנת לחצות אותו ולהדפיס את כל הערכים לקונסולה (או למלא את כל התאים), אנו זקוקים ללולאה כפולה ומקוננת:

for (int i = 0; i < cats.length; i++) {
   for (int j = 0; j < cats[i].length; j++) {
       System.out.println(cats[i][j]);
   }
}

בלולאה החיצונית (משתנה i), אנו מתחלפים בתורות את כל המערכים המרכיבים את המערך הדו-ממדי שלנו. בלולאה הפנימית (משתנה j) אנו עוברים דרך כל התאים של כל מערך. כתוצאה מכך, האובייקט cats[0][0](מערך ראשון, תא ראשון) יוצג ראשון במסוף, והאובייקט השני יהיה cats[0][1](מערך ראשון, תא שני). כאשר המערך הראשון מוצה, , cats[1][0], cats[1][1]וכן cats[1][2]הלאה ייצאו. אגב, אתחול מהיר זמין גם עבור מערכים דו מימדיים:

int[][] numbers = {{1,2,3}, {4,5,6}, {7,8,9}};

בדרך כלל, היינו כותבים מערך דו מימדי numbersבתור int[3][3], אך שיטה זו מאפשרת לנו לציין מיד את הערכים. מדוע ייתכן שיהיה צורך במערך דו מימדי? ובכן, למשל, בעזרתו תוכלו לשחזר בקלות את המשחק המפורסם "Battleship": מבנה מגרש המשחקים ב"Battleship" הוא כזה שניתן לתאר אותו בקלות: מערך דו מימדי של 10 מערכים, 10 תאים כל אחד . אתה יוצר שני מערכים כאלה - עבור עצמך ועבור היריב שלך:

int [][] seaBattle = new int[10][10];
int [][] seaBattle2 = new int[10][10];

אתה ממלא בכמה ערכים (לדוגמה, מספרים או סימנים *) את התאים שבהם הספינות שלך ממוקמות, ואז אתה והיריב מתקשרים בתורו למספרי התאים:

• קרב הים[6][5]!
• עבר! seaBattle2[6][6]!
• נִפגָע!
• seaBattle2[6][7]!
• נִפגָע!
• seaBattle2[6][8]!,
• נהרג!

משאבים נוספים על מערכים

רוצים לדעת עוד על מערכים? אנא עיין במאמרים למטה. יש הרבה מידע מעניין ושימושי בנושא זה.

1. מערכים בג'אווה - מאמר מפורט על מערכים, יצירתם, האתחול והשימוש בהם. עם דוגמאות.
2. המחלקה Arrays והשימוש בה - המאמר מתאר כמה שיטות של המחלקהArray
3. מערכים היא ההרצאה הראשונה של JavaRush המוקדשת למערכים.
4. מערכים רב מימדיים - מאמר מפורט על מערכים רב מימדיים עם דוגמאות.
5. החזר מערך באורך אפס, לא ריק - מחבר תכנות יעיל ג'ושוע בלוך מדבר על איך להחזיר מערכים ריקים בצורה טובה יותר.

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