Arrays

שפת Java – הפעם נלמד arrays.

הדפסת מערך

הדפסת מערך, כאשר כל פעם יש
הורדת שורה [n/]

double[] myList = {0.9,4.6,2.1};
for (int i = 0; i < myList.length; i++) 
{ 
 System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1
}

הסבר:

הגדרנו מערך myList מסוג double (מספרים לא שלמים)

לאחר מכן יש הרצה על מערך כולו תוך שימוש ב-for
למעשה בהתחלה  i=0
לכן:

myList[0]=0.9

בלולאה הבא i=1

לכן:

myList[1]=4.6

וכך עד myList.length כי

for (int i = 0; i < myList.length; i++) 
{ 
 System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1
}

כלומר עד שה-i פחות משלוש:

for (int i = 0; i < 3; i++) 
{  
  System.out.println(myList[i] + " ");//0.9 /n 4.6 /n 2.1 
}

שזה אורך המערך 3 כך שערך אחרון של i זה 2.

לכן כאשר i=2, יודפס:

myList[2]=2.1

מערך דו ממדי:

int[][] foo = new int[][] 
{
 new int[] { 1, 2, 3 },
 new int[] { 1, 2, 3, 4},
};

System.out.println(foo.length); //2
System.out.println(foo[0].length); //3
System.out.println(foo[1].length); //4
System.out.println(foo[1][2]);// 3

הסבר:

הגדרנו מערך דו ממדי בשם foo
1,2,3
1,2,3,4
למעשה במערך דו-מימדי יש שתי שורות:
שורה ראשונה 1,2,3
ושורה שניה 1,2,3,4

בעזרת foo.length מקבלים כמה שורות יש במערך -2

בעזרת foo[0].length מקבלים כמה איברים יש בשורה ראשונה – 3

בעזרת foo[1].length מקבלים כמה איברים יש בשורה השנייה- 4

  • בעזרת [2][1]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 1 ועמודה 2 שזה 3
    
    * ספירה מאפס
  • בעזרת [2][0]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 0 ועמודה 2 שזה 3
    
    * ספירה מאפס
  • בעזרת [1][0]foo ניתן למצוא את האיבר במערך אשר נמצא
    
    בשורה 0 ועמודה 1 שזה 2
    
    * ספירה מאפס

קבלת מערך כאובייקט לפונקציה

קבלת מערך כאובייקט לפונקציה והחזרת מערך עם ערכים מהסוף להתחלה

public class Main {

public static void main(String[] args) {

double[] myList = {0.9,4.6,2.1};

myList=reverse(myList);

for (int i = 0; i < myList.length; i++)
{
System.out.println(myList[i]);//2.1, 4.6, 0.9
}
}

public static double[] reverse(double[] myList) {

double[] result = new double[myList.length];//3

for (int i = 0, j = result.length - 1; i < myList.length; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

return result;//return Array: 2.1, 4.6, 0.9
}

}

הסבר:

הגדרנו מערך myList מסוג double

double[] myList = {0.9,4.6,2.1};

לאחר מכן פונקציה reverse מקבלת מערך myList  וגם מחזירה מערך.

myList=reverse(myList);

כלומר פונקציה מחזירה מערך {2.1,4.6,2,0.9}:

myList= {2.1, 4.6,2, 0.9}

אבל הפונקציה reverse עושה את זה?

תשובה:

נגדיר פונקציה reverse אשר מקבלת מערך חד מימדי – myList מסוג double

public static int[] reverse(double[] myList) 
{  

}

לאחר קבלת מערך myList בפונקציה, נוכל להגדיר מערך זמני בשם result

int[] result = new int[myList.length];

באורך 3 כי

myList.length=3
לכן
int[] result = new int[3];

לאחר מכן אנו מוצאים את האיבר אחרון אשר נמצא במערך myList

for (int i = 0, j = result.length - 1; i < myList.length; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

שזה כמו:

* result.length=3
* myList.length=3

for (int i = 0, j = 3 - 1; i < 3; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

או

for (int i = 0, j = 2; i < 3; i++, j--)
{
result[j] = myList[i];//2.1, 4.6, 0.9
}

ולכן

result[j] = myList[i];
שזה
result[2] = myList[0]=0.9

עם זאת מכיוון שעכשיו:

* i=0
* j=2

 i++, j--
אז
i=1 גדל ב-1
j=1 קטן ב-1

אז בהרצה הבאה של for

result[j] = myList[i];
שזה
result[1] = myList[1]=4.6

לאחר מכן

 i++, j--
אז
i=2 גדל ב-1
j=0 קטן ב-1

ולכן

result[j] = myList[i];
שזה
result[0] = myList[2]=2.1

זאת אומרת במערך result יש מערך הפוך מזה שהתקבל בפונקציה reverse

ובסוף אנו מחזרים את המערך הפוך הזה

 return result;//return Array: 2.1, 4.6, 0.9

ואז מדפיסים את המערך myList

myList=reverse(myList);

for (int i = 0; i < myList.length; i++)
{
System.out.println(myList[i]);//2.1, 4.6, 0.9
}
דילוג לתוכן