אינסופי עבור לולאה (ג 'אווה)

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

ג 'אווה בזמן לולאה: תיאור ודוגמאות

Основополагающим оператором цикла в Java является בעוד. קטע הקוד הקבוע בגופו יחזור על עצמו כל עוד תנאי הביטוי מוקף בסוגריים לאחר שהוא מספק את הערך הלוגי של האמת. הצורה הכללית של ההצהרה בזמן היא כדלקמן:

בעוד (מצב) {

// גוף לולאה

}

ברגע שהערך של המצב הלוגי חדל להיות אמיתי, הקוד המצורף בגוף הלולאה לא יבוצע עוד, והבקרה תועבר לקו מיד לאחר מכן.

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

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

Объявленная переменная count изначально имеет ערך 1. לאחר מכן, אנו רואים ביטוי לוגי מוקף בסוגריים לאחר שם מפעיל. זה יהיה נכון, כלומר החזר את הערך נכון, כל עוד הערך של משתנה הספירה נמוך או שווה ל - 10. בגוף הלולאה, עם כל מעבר (איטרציה), הערך של המשתנה גדל ב -1 ומוצג במסך המסוף. שימו לב שכאשר הערך של המשתנה הגיע ל -11, המחזור נפסק.

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

ראוי לציין שתחביר Java מאפשר זאתהשתמש בהצהרת זמן ללא גוף. בואו נביא דוגמא. נניח שיש לנו שני משתנים i = 100 ו- j = 200, אנו עומדים לפני המשימה לחשב את ממוצע החשבון שלהם באופן פרוגרמטי - לשם כך אתה יכול להשתמש ב"חלול "תוך כדי:

ואילו (++ i <- j);

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

לולאה תוך כדי

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

לעשות {
// גוף לולאה

} תוך (תנאי);

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

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

תיאור ודוגמאות עבור - Java loop

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

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

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

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

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

עבור (int i = 1, int j = 10; i <j; ++ i, --j) {}

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

תכונות השימוש ב- for operator

לולאת ה- for די גמישהלבנות, מכיוון שניתן להשתמש בכל שלושת חלקיו (אתחול, מצב ותוספת / ירידה) מחוץ לתווית. לדוגמא, במקום ביטוי מותנה עם משתנה בקרה, באפשרותך להחליף כל משתנה בוליאני.

יציאה בוליאנית = שקר;

עבור (int i = 0 ;! יציאה; ++ i) {

יציאה = אמת;

}

בדוגמה לעיל, אנו יכולים לראות כיצד העבודההלולאה אינה תלויה לחלוטין במשתנה הבקרה i ומספר האיטרציות תלוי אך ורק ברגע בו היציאה המשתנה הופכת לאמיתית. יתר על כן, ניתן להסיר לחלוטין את משתנה הבקרה מהלולאה וזה לא ישפיע על פעולתו בשום צורה שהיא: עבור (;! יציאה;) {}. אמנם לא הדרך החכמה ביותר לתכנת, אך לפעמים זה יכול להיות שימושי. העיקר הוא לצפות מצב בו המשתנה ייקח את הערך הדרוש ליציאה מהלולאה, כדי לא להפוך אותו לאינסופי.

עבור Java ניתן להכריז על לולאה כזודרך: עבור (;;) {}. זו דוגמה אופיינית לולאה אינסופית עם תנאי הפרעה מיוחדים. נדבר על איך להפריע למחזורים כאלה קצת אחר כך.

לכל לולאה

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

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

הצהרות הפרעה בלולאה

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

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

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

שימוש בשבירה כגוטו

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

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

הקוד מצהיר על שלוש בלוקים עם שמות התוויות One,שתיים ושלוש, בהתאמה. הצהרת ההפסקה שכותרתה Two מקוננת בכל שלושת הבלוקים, אך כאשר היא מופעלת, התוכנית תצא מהבלוקים Three ו- Two ותמשיך בביצוע בבלוק האחד. הָהֵן. נראה שתי הודעות במסוף: שלוש ואחת.

מסקנה

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