מערכים ב-Java

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

מהו מערך?

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

הצהרת מערך

איך להכריז על מערך?

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

יצירת מערך

איך יוצרים מערך?

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

new typeOfArray [length];

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

int[] myArray; // array declaration
myArray = new int[10]; // creation, that is, allocation of memory for an array of 10 elements of type int

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

int[] myArray = new int[10]; // declaration and allocation of memory "in one bottle"

הערה:לאחר יצירת מערך באמצעות new , התאים שלו מתמלאים בערכי ברירת מחדל. עבור טיפוסים מספריים (כמו בדוגמה שלנו) זה יהיה 0, עבור boolean - false , עבור טיפוסי הפניה - null . כך, לאחר הניתוח

int[] myArray = new int[10];

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

אורך מערך ב-Java

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

int[] myArray = new int[10]; // created an array of integers with 10 elements and named it myArray
System.out.println(myArray.length); // printed to the console the length of the array, that is, the number of elements that we can put in the array

פלט תוכנית:

אתחול מערך וגישה לאלמנטים שלו

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

String[] seasons  = new String[4]; /* declared and created an array. Java allocated memory for an array of 4 strings, and now each cell is null (because the string is a reference type)*/

seasons[0] = "Winter"; /* in the first cell, that is, in the cell with a zero number, we wrote the string Winter. Here we get access to the zero element of the array and write a specific value there */
seasons[1] = "Spring"; // do the same procedure with cell number 1 (second)
seasons[2] = "Summer"; // ...number 2
seasons[3] = "Autumn"; // and with the last one, number 3

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

String[] seasons  = new String[] {"Winter", "Spring", "Summer", "Autumn"};

יתר על כן, ניתן להשמיט את האופרטור החדש :

String[] seasons  = {"Winter", "Spring", "Summer", "Autumn"};

כיצד להציג מערך ב-Java על המסך?

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

String[] seasons  = new String[] {"Winter", "Spring", "Summer", "Autumn"};
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]);
}

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

מערכי Java חד מימדיים ורב מימדיים

מה אם נרצה ליצור לא מערך של מספרים, מערך של מחרוזות או מערך של כמה אובייקטים, אלא מערך של מערכים? Java מאפשרת לך לעשות זאת. המערך המוכר כבר int[] myArray = new int[8] הוא מה שנקרא מערך חד מימדי. ומערך של מערכים נקרא דו מימדי. זה כמו טבלה שיש לה מספר שורה ומספר עמודה. או, אם למדת את ההתחלה של אלגברה לינארית, על מטריצה. למה צריך מערכים כאלה? בפרט, לתכנות את אותן מטריצות וטבלאות, כמו גם אובייקטים הדומים להם במבנה. לדוגמה, ניתן לציין את מגרש המשחקים בשחמט כמערך 8x8. מערך רב מימדי מוכרז ונוצר באופן הבא:

int[][] myTwoDimentionalArray = new int [8][8];

יש בדיוק 64 אלמנטים במערך הזה: myTwoDimentionalArray[0][0], myTwoDimentionalArray[0][1], myTwoDimentionalArray[1][0], myTwoDimentionalArray[1][1]וכן הלאה עד myTwoDimentionalArray[7][7]. אז אם נשתמש בו כדי לייצג לוח שחמט, אז התא A1 ייצג myTwoDimentionalArray[0][0]ו-E2 ייצג את myTwoDimentionalArray[4][1]. איפה שיש שניים, יש שלושה. ב-Java, אתה יכול לציין מערך של מערכים... מערך של מערכים של מערכים, וכן הלאה. נכון, נעשה שימוש במערכים תלת מימדיים ויותר לעתים רחוקות מאוד. עם זאת, באמצעות מערך תלת מימדי, ניתן לתכנת, למשל, קוביית רוביק.

שיטות שימושיות לעבודה עם מערכים

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

מיין מערך

השיטה void sort(int[] myArray, int fromIndex, int toIndex)ממיינת מערך של מספרים שלמים או תת-מערך שלו בסדר עולה.

חיפוש במערך אחר האלמנט הרצוי

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key). שיטה זו מחפשת את רכיב המפתח ב- myArray או תת-מערך שכבר ממוינים , החל מ- fromIndex וכלה ב- toIndex . אם האלמנט נמצא, השיטה מחזירה את האינדקס שלה, אם לא - . (-fromIndex)-1

המרת מערך למחרוזת

השיטה String toString(int[] myArray)ממירה את המערך למחרוזת. העניין הוא שבמערכי Java לא עוקפים את toString() . המשמעות היא שאם תנסה להציג את המערך כולו (ולא אלמנט אחר אלמנט, כמו ב"הדפסת מערך למסך ") למסך ישירות ( System.out.println(myArray)), תקבל את שם המחלקה ואת קוד הגיבוב ההקסדצימלי של המערך (זה מוגדר על ידי Object.toString() ). אם אתה מתחיל, ייתכן שלא תבין את ההסבר של השיטה toString. בשלב הראשון זה לא הכרחי, אבל באמצעות שיטה זו הפלט של המערך מפושט. Java מקלה על הצגת מערך מבלי להשתמש בלולאה. עוד על כך בדוגמה למטה.

דוגמה על sort, binarySearch ו-toString

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

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; //declaring and initializing the array
        System.out.println(array);//trying to display our array on the screen without the toString method - we get a hexadecimal number
        System.out.println(Arrays.toString(array));//печатаем массив "правильно"
        Arrays.sort(array, 0, 4); // sort the entire array from zero to the fourth member
        System.out.println(Arrays.toString(array));//print the sorted array to the screen
        int key = Arrays.binarySearch(array, 5); // ищем key - число 5 в отсортированном массиве.
        //binarySearch method will return the index of the sorted array element, in which the required number is "hidden"
        System.out.println(key);//распечатываем индекс искомого числа
System.out.println(Arrays.binarySearch(array, 0));//а теперь попробуем найти число, которого в массиве нет,
        // and immediately display the result on the screen

    }
}

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

העיקר לגבי מערכים

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

• יש להגדיר את גודל המערך (מספר התאים) ב- int

• לא ניתן לשנות את האורך של מערך לאחר יצירתו.

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

• במערכים, כמו במקומות אחרים בג'אווה, אלמנטים ממוספרים החל מאפס.

• לאחר הליך יצירת המערך, הוא מלא בערכי ברירת מחדל.

• מערכים ב-Java בנויים אחרת מאשר ב-C++. הם כמעט זהים למצביעים למערכים דינמיים.

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

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

1. משהו על מערכים - מאמר מפורט טוב על מערכים

2. המחלקה Arrays והשימוש בה - המאמר מתאר כמה שיטות של המחלקה Array

3. מערכים רב מימדיים - מאמר מפורט על מערכים רב מימדיים עם דוגמאות.

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