ג'אווה איטרטור

היי! בשיעור של היום, נדבר על Java Iterator. תאר לעצמך שאתה הולך לספרייה, ואתה רוצה למצוא ספר מסוים. איך אתה עושה את זה? אם זה עיון, יש את המערכת העשרונית של דיואי. אם זה בדיוני, הם ממוינים בסדר אלפביתי לפי שם המשפחה שלהם. לא משנה מה אתה מחפש, בשלב מסוים, אתה צריך לעבור על הספרים אחד אחד עד שתמצא את מה שאתה מחפש. בכל פעם שיש לך אוסף של דברים ב-Java, בין אם הוא מאוחסן במערך , ב- ArrayList , בתור , או ברשימה , איך אתה מוצא ערך מסוים? בשלב מסוים, אתה צריך לעבור על כל אלמנט אחד בכל פעם. בשביל זה נועד איטרטור ג'אווה.

מהו איטרטור בג'אווה

מהו איטרטור בג'אווה? זוהי דרך להסתכל על כל אלמנט באוסף. ובאיסוף, אנחנו מתכוונים לכל דבר בשיעור האיסוף . זה כולל:

• רשימת מערך
• HashSet
• LinkedHashSet
• רשימה מקושרת
• PriorityQueue
• וֶקטוֹר
• ורבים אחרים…

הוא כולל גם את הממשקים השונים עבור אותם מחלקות, כגון סט , רשימה , תור , תור , וסדר ממוין , כדי לציין כמה. Iterator<E> היא שיטת הממשק הציבורי של המחלקה Interface Iterator<E> . זה נוצר ב-Java 1.2 והחליף את Enumeration כדרך לבחון אלמנטים עוקבים באוסף.

מדוע לא כדאי להשתמש ב-For Loops כאיטרטור ב-Java

אחת הדרכים הראשונות שבהן מלמדים את כולם לחזור על אוסף בג'אווה היא לולאה. זה נראה כמו זה:

class Main {
  public static void main(String[] args) {
    int exampleArray[] = new int[10];

    //fill array with data

    for(int x = 0; x < exampleArray.length; x++) {
      System.out.println("Content of element " + x + "is: " + exampleArray[x]);
    }
  }
}

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

Content of element 0 is: 0
Content of element 1 is: 1
Content of element 2 is: 2
etc.…

יש לזה שימושים, אבל מה קורה אם האוסף לא מאחסן אלמנטים במערכת מבוססת אינדקס? לדוגמה, לסטים אין סדר בדרך כלל. לכן מומלץ לצאת מהתרגול של שימוש בלולאה for כאיטרטור בג'אווה ולתרגל במקום זאת שימוש במחלקה Iterator<E> . הנה כמה דוגמאות ל-Java Iterator.

כיצד להשתמש באיטרטור ב-Java

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

import java.util.*; // imports ArrayList, Collection and Iterator

class Main {
  public static void main(String[] args) {
    Collection<String> example = new ArrayList<String>();

    example.add("Item 1");
    example.add("Item 2");
    example.add("Item 3");
    example.add("Item 4");
  }
}

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

לולאה While()

Iterator<String> iterator = example.iterator();

while (iterator.hasNext()) {
   System.out.println("Element Value= " + iterator.next());
}

לולאת while() זו משתמשת בשיטה הבוליאנית .hasNext() של המחלקה Iterator כדי לבדוק אם יש אלמנט עתידי. אם התנאי המוקדם נכון, אז זה ממשיך. אם הוא חוזר כ-false, אז הלולאה מסתיימת. החלק המרכזי כאן הוא שהשיטות .hasNext() וה- .next() עושות שתיהן בדיקה ראשונית של האלמנט הראשון. אם האוסף ריק ואין אלמנט ראשון, השיטה מחזירה false עבור ‎.hasNext() ותזרוק NoSuchElementException עבור שיטת .next() .

עבור לולאה

for (Iterator<String> iterator = example.iterator(); iterator.hasNext();) {
  System.out.println("Element Value= " + iterator.next());
}

זה נראה כמו לולאה מסורתית יותר. הוא משתמש בשיטת .hasNext() כחלק לבדיקת מצב ושינוי. האתחול הוא הקריאה לאיטרטור.

עבור: כל לולאה

for (String s : example) {
  System.out.println("Element Value= " + s);
}

לולאת For:Each היא לולאת for, אך אם אינך יודע כיצד לקרוא אותה, היא עשויה להיות מעט מבלבלת. התחביר של לולאה For:Each הוא עבור (data_type variableName : collectionName){ body} . זה עבור: לכל לולאה יש כמה חסרונות. ראשית, הוא יכול לחצות את האוסף רק בכיוון אחד. שנית, אתה צריך לחזור על כל אלמנט. אתה לא יכול לדלג על אף אחד מהם. אבל בתור איטרטור רשימות נוח בג'אווה, זו האפשרות הטובה ביותר. בצד החיובי, קל מאוד לקרוא את הלולאה for:each וברגע שאתה יודע אותה, קשה לטעות. אם אתה תוהה מה הפלט של שלוש לולאות האיטרטור, כולן זהות:

Element Value= Item 1
Element Value= Item 2
Element Value= Item 3
Element Value= Item 4 

כיצד להשתמש באיטרטור ב-Java For Maps

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

import java.util.*; //imports Map and HashMap

class Main {
  public static void main(String[] args) {
    Map<String, String> example = new HashMap<String, String>();

    example.put("alpha", "one");
    example.put("beta", "two");
    example.put("gamma", "three");

  }
}

שיטת Java Hashmap Iterator: forEach(action)

example.forEach((k,v) -> System.out.println("Key: "+ k + ", Value: " + v));

שיטה זו משתמשת בביטוי למבדה כדי לחזור עליו. האופרטור lambda הוא שיטת forEach() והגוף מדפיס את הערכים. זה משתמש באופרטור מרובה פרמטרים. זוהי השיטה המהירה והנקייה ביותר עבור איטרטור מפות ב-Java 8.

שיטת Java Hashmap Iterator: For:Each() Loop

for (Map.Entry<String, String> iterate : example.entrySet()) {
  System.out.println("Key: " + iterate.getKey() + ", Value: " + iterate.getValue());
}

זה משתמש בתחביר For:Each כדי לקרוא למתודה entrySet() כדי להחזיר קבוצה שיש לה את המפתח והערך כאלמנטים שלה. בנוסף, בעת שימוש בשיטת .Entry() , האובייקטים נכונים רק בזמן איטרציה זו.

שיטת Java Hashmap Iterator: Map.Entry<k, v>

Iterator<Map.Entry<String, String>> iterator = example.entrySet().iterator();

while(iterator.hasNext()){
  Map.Entry<String, String> element = iterator.next();
  System.out.println("Key: " + element.getKey() + ", Value: " + element.getValue());
)

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

Key: alpha, Value: one
Key: beta, Value: two
Key: gamma, Value: three
Java Hashmap Iterator Method: keySet() and values()
for (String key : example.keySet()) {
  System.out.println("Key: " + key);
}
for (String value : example.values()) {
  System.out.println("Value: " + value);
}

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

Key: alpha
Key: beta
Key: gamma
Value: one
Value: two
Value: three