streamalism.org

1. הקדמה

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

הוא הוצג לראשונה ב- Java 1.2 כתחליף ל- ספירות ו:

• הציג שמות שיטות משופרים
• אפשרה להסיר אלמנטים מאוסף שעליו אנו חוזרים
• אינו מבטיח צו איטרציה

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

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

2. ה איטרטור מִמְשָׁק

כדי להתחיל, עלינו להשיג איטרטור מ אוסף; זה נעשה על ידי קריאה ל איטרטור () שיטה.

לשם פשטות, נשיג איטרטור מופע מרשימה:

פריטי רשימה = ... איטרטור איטר = items.iterator ();

ה איטרטור לממשק שלוש שיטות ליבה:

2.1. hasNext ()

ה hasNext () ניתן להשתמש בשיטה לבדיקה אם נותר לפחות אלמנט אחד לחזור עליו.

זה נועד לשמש כתנאי ב בזמן לולאות:

בעוד (iter.hasNext ()) {// ...}

2.2. הַבָּא()

ה הַבָּא() ניתן להשתמש בשיטה עבור מעבר על האלמנט הבא והשגתו:

מחרוזת הבאה = iter.next ();

זה נוהג טוב להשתמש hasNext () לפני שתנסה להתקשר הַבָּא().

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

2.3. לְהַסִיר()

לבסוף, אם נרצה הסר את האלמנט הנוכחי מהאוסף, אנחנו יכולים להשתמש ב- לְהַסִיר:

iter.remove ();

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

2.4. מלא איטרטור דוגמא

כעת נוכל לשלב את כולם ולבדוק כיצד אנו משתמשים בשלוש השיטות יחד לסינון אוספים:

בעוד (iter.hasNext ()) {String next = iter.next (); System.out.println (הבא); if ("TWO" .equals (הבא)) {iter.remove (); }}

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

2.5. מתבוסס עם ביטויים למבדה

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

מאז Java 8, יש לנו את forEachRemaining שיטה המאפשרת שימוש במבדות לעיבוד האלמנטים הנותרים:

iter.forEachRemaining (System.out :: println);

3. ה ListIterator מִמְשָׁק

ListIterator היא סיומת שמוסיפה פונקציונליות חדשה לאיטרציה ברשימות:

ListIterator listIterator = items.listIterator (items.size ());

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

3.1. hasPrevious () ו קודם()

ListIterator יכול לשמש למעבר לאחור כך שהוא מספק שווי ערך של hasNext () ו הַבָּא():

while (listIterator.hasPrevious ()) {String הקודם = listIterator.previous (); }

3.2. nextIndex () ו previousIndex ()

בנוסף, אנו יכולים לחצות מדדים ולא אלמנטים ממשיים:

מחרוזת nextWithIndex = items.get (listIterator.nextIndex ()); מחרוזת previousWithIndex = items.get (listIterator.previousIndex ());

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

3.3. לְהוֹסִיף()

ה לְהוֹסִיף שיטה, אשר, כפי שהשם מרמז, מאפשרת לנו להוסיף אלמנט לפני הפריט שיוחזר על ידי הַבָּא() ואחרי זה שחזר על ידי קודם():

listIterator.add ("FOUR");

3.4. מַעֲרֶכֶת()

השיטה האחרונה שכדאי להזכיר היא מַעֲרֶכֶת(), המאפשר לנו להחליף את האלמנט שהוחזר בשיחה אליו הַבָּא() אוֹ קודם():

מחרוזת הבאה = listIterator.next (); if ("ONE" .equals (next)) {listIterator.set ("SWAPPED"); }

חשוב לציין זאת ניתן לבצע זאת רק אם אין שיחות קודמות לְהוֹסִיף() אוֹ לְהַסִיר() נעשו.

3.5. מלא ListIterator דוגמא

כעת נוכל לשלב את כולם כדי ליצור דוגמה מלאה:

ListIterator listIterator = items.listIterator (); while (listIterator.hasNext ()) {String nextWithIndex = items.get (listIterator.nextIndex ()); מחרוזת הבאה = listIterator.next (); if ("REPLACE ME" .equals (next)) {listIterator.set ("REPLACED"); }} listIterator.add ("חדש"); while (listIterator.hasPrevious ()) {String previousWithIndex = items.get (listIterator.previousIndex ()); מחרוזת הקודם = listIterator.previous (); System.out.println (הקודם); }

בדוגמה זו, אנו מתחילים לקבל את ListIterator מ ה רשימהואז נוכל להשיג את האלמנט הבא לפי אינדקס -מה שלא מגדיל את אלמנט הזרם הפנימי של האיטרטור - או על ידי התקשרות הַבָּא.

אז נוכל להחליף פריט ספציפי ב- מַעֲרֶכֶת והכנס חדש עם לְהוֹסִיף.

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

4. מסקנה

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

לבסוף, כמו תמיד קוד המקור המלא זמין ב- GitHub.