מערכים ומחרוזות

- מבוא
- הקדמה
- מערכים
- מערכים של אובייקטים
- מחרוזות
- חיבור מחרוזות
-  מערך של הצבעות על מחרוזת
- שאלות סיכום

מבוא

סטודנטים בקורס הקדמה לתכנות Java אחראים לידיעת והבנת כל החומר בשעור זה
(חוץ מנושאים ספציפיים ב – C++).

הנושאים הספציפיים ב – C++ מוצעים כחומר משלים לטובת אלו שמכירים כבר C++
ומבצעים הסבה ל – Java.

הקדמה

הצעד הראשון

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

טיפוסי מערכים ומחרוזות

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

מערכים

מערכים ב‑ ++C

ב‑ ++C לא קיים טיפוס מערך אמיתי, ואילו טיפוס מחרוזת לא קיים בה כלל
(אבל מחלקת string הוצעה עבור סטנדרט ה­‑ANSI החדש).

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

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

מערכים ומחרוזות ב‑ Java

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

הצהרה על מערך

ב‑Java עליך להצהיר על מערך לפני שתוכל להשתמש בו. בעת הצהרה על מערך עליך לספק שתי פיסות מידע חשובות:

·       שמו של המערך

·       טיפוס הנתונים שיאוחסן בו

פורמטים שונים להצהרה

ב‑Java ניתן להצהיר על מערכים באחד משני הפורמטים הבאים, כמוצג למטה:

int[] myArray;
int myArray[];

ההצהרה אינה מקצה זיכרון

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

כיצד מקצים זיכרון עבור הנתונים?

את הזיכרון, שיכיל את נתוני המערך, יש להקצות מתוך הזיכרון הדינמי באמצעות הוראות כגון:

int[] myArray = new int[15];
int myArray[] = new int[25];

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

האם ניתן להפריד הצהרה מהקצאה?

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

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

הפרדת ההצהרה מן ההקצאה

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

int[] myArray;
. . .
myArray = new int[25];

שילוב של הצהרה ויצירה של מופע

התחביר הכללי לשם הצהרה על מערך ויצירתו מובא בקטע הקוד הבא:

typeOfElements[] nameOfArray = 
     new typeOfElements[sizeOfArray]

הגישה לאיברי המערך

לאחר יצירת מערך ב‑Java, ניתן לגשת אל איבריו באמצעות תחביר אינדקס,
הדומה לזה של שפת ++C ושפות רבות אחרות:

myArray[5] = 6;

myVar = myArray[5];

שימוש במחוונים לשם גישה לאיברי מערך ב‑++C

בניגוד ל- ++C , Java אינה מאפשרת גישה לאיברי המערך באמצעות מחוונים
(Java אינה תומכת במחוונים).

מה ערכו של האינדקס הראשון?

כמו ב‑ ++C, האינדקסים של מערך ב‑ Java תמיד מתחילים ב‑0.

מאפיין length של מערך

קטע הקוד הבא ממחיש היבט מעניין נוסף של מערכים ב‑Java. שים לב לשימוש ב‑ length בקוד הבא.

for(int cnt = 0; cnt < myArray.length; cnt++) 
  myArray[j] = j;

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

אילו טיפוסים ניתן לאחסן במערכים של Java?

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

אמצעי זהירות לגבי מערכי מחרוזת

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

בניית מערכים רב-מימדיים

יצירת מערך שיכיל איברים שהם מערכים בפני עצמם, היא דרך טובה לבניית מערכים רב-מימדיים, הן ב‑Java והן ב‑++C .

מערכים רב-מימדיים חריגֵי-צורה

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

בתוכנית זו מוצהר ונוצר מערך דו-מימדי של מספרים שלמים, כאשר הגודל הראשי (הגודל של המימד הראשון) הוא שלוש. הגדלים של המימדים המשניים (גודלו של כל תת-מערך) הם 2, 3, ו‑4, בהתאמה.

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

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

גישה למערך מחוץ לגבולותיו ב‑ Java

התוכנית גם ממחישה את תוצאת הניסיון לגשת לאיבר שמחוץ לגבולות המערך ב‑Java
Java מגינה עליך מפני שגיאות תכנות ממין זה.

גישה למערך מחוץ לגבולותיו ב‑ ++C

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

ArrayIndexOutOfBoundsException

ב‑Java מופיעה  חריגה במידה ואתה מנסה לגשת למערך מחוץ לגבולותיו,
כפי שמראה התוכנית הבאה.

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

תוכנית לדוגמה

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

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

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

/*File array01.java Copyright 1997, R.G.Baldwin
Illustrates creation and manipulation of two-dimensional 
array with the sub arrays being of different lengths.

Also illustrates detection of exception when an attempt is
made to store a value out of the array bounds.

This program produces the following output:

00
012
0246
Attempt to access array out of bounds
java.lang.ArrayIndexOutOfBoundsException:
     at array01.main(array01.java: 47)

**********************************************************/
class array01 { //define the controlling class
  public static void main(String[] args){ //main method
    //Declare a two-dimensional array with a size of 3 on 
    // the primary dimension but with different sizes on 
    // the secondary dimension.
    //Secondary size not specified initially
    int[][] myArray = new int[3][];
    myArray[0] = new int[2];//secondary size is 2
    myArray[1] = new int[3];//secondary size is 3
    myArray[2] = new int[4];//secondary size is 4

    //Fill the array with data
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < myArray[i].length; j++){
        myArray[i][j] = i * j;
      }//end inner loop
    }//end outer loop

    //Display data in the array
    for(int i = 0; i < 3; i++){
      for(int j = 0; j < myArray[i].length; j++){
        System.out.print(myArray[i][j]);
      }//end inner loop
      System.out.println();
    }//end outer loop

    //Attempt to access an out-of-bounds array element
    System.out.println(
                  "Attempt to access array out of bounds");
    myArray[4][0] = 7;
    //The above statement produces an ArrayIndexOutOfBounds
    // exception.

  }//end main
}//End array01 class.  

הגנה מפני שגיאות חריגה מגבול ב‑ ++C

אף על פי שניתן ליצור תוכנית ++C שתחקה את התנהגותה של תוכנית Java זו באמצעות יצירת מחלקת Array מיוחדת, תוכנית כזו תהיה מסובכת למדי, ולהשוואה בינה לבין תוכנית ה‑Java הנ"ל לא יהיה ערך לימודי רב. לכן, במקרה זה, לא הבאנו תוכנית ++C דומה לה.

השמה של מערך אחד לאחר: נהג בזהירות!

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

תוכנית לדוגמה להמחשת השמה של מערכים

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

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

/*File array02.java Copyright 1997, R.G.Baldwin
Illustrates that when you assign one array to another 
array, you end up with two references to the same array.

The output from running this program is:

firstArray contents
0 1 2
secondArray contents
0 1 2
Change a value in firstArray and display both again
firstArray contents
0 10 2
secondArray contents
0 10 2
**********************************************************/
class array02 { //define the controlling class
  int[] firstArray;
  int[] secondArray;

  array02() {//constructor
    firstArray = new int[3];
    for(int cnt = 0; cnt < 3; cnt++) firstArray[cnt] = cnt;

    secondArray = new int[3];
    secondArray = firstArray;
  }//end constructor

  public static void main(String[] args){//main method
    array02 obj = new array02();
    System.out.println( "firstArray contents" );
    for(int cnt = 0; cnt < 3; cnt++)
      System.out.print(obj.firstArray[cnt] + " " );
    System.out.println();

    System.out.println( "secondArray contents" );
    for(int cnt = 0; cnt < 3; cnt++)
      System.out.print(obj.secondArray[cnt] + " " );

    System.out.println();
    System.out.println(
      "Change value in firstArray and display both again");
    obj.firstArray[1] = 10;

    System.out.println( "firstArray contents" );
    for(int cnt = 0; cnt < 3; cnt++)
      System.out.print(obj.firstArray[cnt] + " " );
    System.out.println();

    System.out.println( "secondArray contents" );
    for(int cnt = 0; cnt < 3; cnt++)
      System.out.print(obj.secondArray[cnt] + " " );

    System.out.println();
  }//end main
}//End array02 class.