מערכים ב-Java

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

מהו מערך?

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

הכרזה על מערך

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

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

יצירת מערך

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

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

new typeOfArray[length];

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

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

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

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

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

int[] myArray = new int[10];

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

אורך מערך ב-Java

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

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

תְפוּקָה:

10

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

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

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 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]);
}

התוכנית תציג את הדברים הבאים:

Winter 
Spring 
Summer 
Autumn

מערכים חד מימדיים ורב מימדיים בג'אווה

אבל מה אם אנחנו רוצים ליצור לא מערך של מספרים, מחרוזות או אובייקטים אחרים, אלא מערך של מערכים? 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)) במקום אלמנט אחד בכל פעם כמו בפסקה שכותרתה " הצג מערך על המסך ", תקבל את שם המחלקה וה-hash הקסדצימלי של המערך (מוגדר על ידי Object.toString() ). אם אתה מתחיל, ייתכן שלא תבין את ההסבר לגבי שיטת toString . בתחילה, אין צורך בכך, אך שימוש בשיטה זו מקל על הצגת מערך. Java מאפשרת לך להציג מערך בקלות מבלי להשתמש בלולאה. הדוגמה להלן מדגימה זאת.

דוגמה באמצעות sort, binarySearch ו-toString

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

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array.
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array,
        // and immediately display the result

    }
}

תְפוּקָה:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

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

מערכים בקצרה

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

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

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

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

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

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

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

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

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