PracticU

Looping over Arrays

בלי כתוביותעם כתוביות
PracticU › קורס יסודות התכנות - שפת JAVA - קורס ג'אווה למתחילים › Looping over Arrays
Looping over Arrays
לולאה מאפשרת לקלוט, להציג ולחשב על כל תאי המערך בקוד קצר, לא משנה כמה תאים יש בו.
השלבים העיקריים
1. קליטה לתוך מערך: לולאת for (int i = 0; i < 7; i++) עוברת על כל התאים. בכל חזרה grades[i] = scanner.nextInt();. האינדקס i מייצג את המיקום בתוך המערך.
2. תנאי הסיום: מסתכלים על i קטן מהגודל, לא קטן-שווה, כי אין תא שמספרו שווה לגודל.
3. הצגה: לולאה נפרדת שמציגה את כל התאים. כך אפשר להציג את הערכים רק אחרי שכל הקליטה הסתיימה.
4. חישוב ממוצע: לולאה שלישית שמחברת את כל התאים ומחלקת בגודל.
5. length במקום מספר קבוע: grades.length נותן את גודל המערך. כך משנים את הגודל במקום אחד בלבד, ולא בכל שורה שמופיע בה מספר.
טעויות נפוצות
- שימוש ב-<= בתנאי הלולאה גורם לחריגה מהגבולות.
- בחישוב הממוצע צריך לבצע cast לאורך המערך, או לחלק במספר עשרוני. הגדרת ה-sum כ-double פחות מומלצת, כי הערכים עצמם מסוג int.
שימו לב
הדפוס הרגיל הוא שלוש לולאות נפרדות: אחת לקליטה, אחת להצגה ואחת לחישוב.
השיעור הבא בקורס: Initializing Arrays
מילון מושגים:
לולאה – מבנה בקרה שחוזר על קטע קוד שוב ושוב כל עוד תנאי מתקיים או עבור כל פריט באוסף.
מערך – מבנה נתונים שמאחסן אוסף ערכים מאותו סוג ברצף, שאפשר לגשת אליהם לפי מספר מיקום (אינדקס).
אינדקס – מבנה במסד נתונים שמאיץ חיפוש ושליפה; גם מספר המציין מיקום של איבר במערך.
תנאי – ביטוי לוגי בקוד שתוצאתו אמת או שקר, וקובע אילו פקודות יתבצעו בהתאם לערכו.
חריגה – מצב שגיאה שמתרחש בזמן ריצת התוכנית ומפסיק את המהלך הרגיל, אלא אם הקוד תופס ומטפל בו.

פרקי ההרצאה: Looping over Arrays

  1. 00:00

    מערך ציונים וקליטה בלולאה

  2. 00:41

    עדיף לולאה על פני שורת קוד לכל תא

  3. 01:39

    שימוש ב-i כאינדקס לקליטת הערכים

  4. 02:24

    הרצה של הקליטה ותיקון תנאי הלולאה

  5. 03:12

    הצגת הציונים בלולאה נפרדת

  6. 04:10

    למה כדאי להפריד בין קליטה והצגה

  7. 04:45

    חישוב ממוצע בלולאה שלישית

תמלול ההרצאה: Looping over Arrays

הטקסט המלא של הדקות הראשונות בהרצאה «Looping over Arrays» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:02

    אז איך אנחנו יכולים ליצור מערך ולבצע סריקה של המערך הזה על ידי לולאה? בואו ניקח מה שהיה לנו מקודם, מערך ציונים. ניקח grades שווה new grades, סליחה, new int וגודל ובואו נניח שאנחנו רוצים הפעם שבע ציונים מהיוזר, אז שבעה ציונים.

  2. 00:29

    אז איך אנחנו יכולים בבת אחת לומר ליוזר enter seven grades? אנחנו לא רוצים ללכת לגריידס במיקום 0 ולהכניס אליו נתון בודד, גריידס במיקום 1 להכניס נתון בודד, כי כמובן אנחנו רוצים לבצע את הכל בצורה ממש מצומצמת מבחינת קוד.

  3. 00:52

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

  4. 01:09

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

  5. 01:26

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

  6. 01:49

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

  7. 02:09

    במקרה הזה אני רוצה להכניס אליו ערך. בואו ניגש ל-console.read.nextint והלולאה הזאת מבצעת סריקה של כל המערך וקולטת לתוכו ערכים מהמשתמש.

  8. 02:31

    אם אנחנו מריצים את זה, אז אנחנו יכולים לראות שיש לנו פה enter 7 grades, בואו נכניס 100, 90, 80, 85, 50, 70, 90 ו-58.

  9. 02:53

    ואנחנו רואים שיש לנו את הקריסה הסופית, כי יש לנו פה את הקטן שווה ל-7. בואו ניפטר ממנו, נריץ שוב, ויש לנו 100, 90, 80, 70, 50, 60, עוד 90 והתוכנית הסתיימה.

  10. 03:15

    יש לנו כאן, כמו שאנחנו רואים, שבעה מספרים. אם אנחנו רוצים גם לרוץ ולהציג את המידע במערך, בואו ניקח לולאה נוספת, int i שווה 0, i קטן מ-7, שוב פעם אותו הדבר, i++, ומה שאנחנו רוצים לעשות זה sysout של grades במיקום i, נשרשר אותו עם איזשהו רווח שכולם יהיו באותה

  11. 03:43

    שורה. בואו נריץ, ולבסוף אנחנו נראה את הציונים מוצגים על המסך. 190, 80, 70, 60, 59 ו-72, והנה כל הציונים מוצגים על המסך.

  12. 04:01

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

  13. 04:19

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

  14. 04:32

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

  15. 04:47

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

  16. 05:05

    sum פלוס שווה ל-grades במיקום i, בואו ניקח

לקורס המלא: קורס ג'אווה למתחילים אונליין

ההרצאה הקודמת: Creating and Using Arrays

ההרצאה הבאה: Initializing Arrays

קורסים נוספים במסלול

  • קורס מבוא ל-QA - מידע חשוב לבודק תוכנה
  • קורס פוסטמן - Postman - בדיקות לאתרי אינטרנט - API
  • קורס Robot Framework - בדיקות QA ממשק גרפי
  • קורס סלניום בסיסי - בדיקות אוטומטיות - Selenium
  • קורס סלניום מתקדם - CI/CD - Continues Integration
  • קורס מייבן - Maven