שפת 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
}
