משהו על מערכים

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

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];

   }
}

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

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


2. יש לציין את גודלו בעת יצירת המערך . לא ניתן לציין אותו מאוחר יותר או לשנות את גודלו לאחר יצירת המערך .

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

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] = "Jana Russell, March 12";
   }
}

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";
   }
}

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

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

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

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, 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] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[2] = "Jeremiah Leonard, July 12";
       birthdays [3] = "Kenny Russo, September 7";
       birthdays[4] = "Tommie Barnes, November 9";
       birthdays [5] = "Roman Baranov, August 14";
       birthdays [6] = "Chanice Andersen, April 1";
       birthdays[7] = "Rosie Mills, January 3";
       birthdays [8] = "Keenan West, October 19";
       birthdays [9] = "Abraham McArthur, May 3";

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

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

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 עכשיו, קצת על האופן שבו מערכים מאוחסנים בזיכרון. נניח שיש לנו מערך של שלושה 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("Behemoth");
       cats[2] = new Cat("Lionel Messi");
   }
}

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

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

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

לפיכך, catsמתייחס לגוש הזיכרון שבו מאוחסנים כל האובייקטים (רכיבי מערך). Cats[0]מפנה לכתובת ספציפית בתוך בלוק זה. חשוב להבין שמערך לא מאחסן רק אובייקטים: הוא אובייקט עצמו. זה מוביל אותנו לשאלה האם אנחנו יכולים ליצור לא רק מערך של מחרוזות או מספרים, אלא גם מערכים של מערכים . והתשובה היא כן, אנחנו יכולים! מערך יכול לאחסן כל אובייקט, כולל מערכים אחרים. מערך כזה נקרא דו מימדי . אם היינו מייצגים אותו חזותית, הוא יהיה דומה מאוד לטבלה רגילה. נניח שאנו רוצים ליצור מערך של 3 מערכים שיכולים לאחסן כל 10 intשניות. זה ייראה כך: כל שורה מייצגת 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("Fluffy");
}

[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] (מערך ראשון, אלמנט ראשון) יוצגו תחילה, ואחריו חתולים[0][1] (מערך ראשון, אלמנט שני). לאחר שעברנו את המערך הראשון, נציג חתולים[1][0] , חתולים[1][1] , חתולים[1][2] וכו'. אגב, גם מערכים דו מימדיים תומכים אתחול קיצור:

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

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

int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];

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

• battleshipBoard1[0][2]!
• עלמה! BattleshipBoard2[2][4]!
• מכה!
• BattleshipBoard2[2][5]!
• מכה!
• BattleshipBoard2[2][6]!,
• שקוע!

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