Java Iterator

Hi! Sa aralin ngayon, pag-uusapan natin ang tungkol sa Java Iterator. Isipin na pupunta ka sa library, at gusto mong makahanap ng isang partikular na libro. Paano mo ito gagawin? Kung ito ay non-fiction, mayroong Dewey Decimal System. Kung ito ay kathang-isip, pinagbukud-bukod sila sa alpabetikong pagkakasunud-sunod ng kanilang apelyido. Anuman ang iyong hinahanap, sa isang punto, kailangan mong suriin ang mga libro nang paisa-isa hanggang sa makita mo ang iyong hinahanap. Sa tuwing mayroon kang isang koleksyon ng mga bagay sa Java, kung ito ay naka-imbak sa isang Array , isang ArrayList , isang Queue , o isang Listahan , paano mo mahahanap ang partikular na halaga? Sa ilang mga punto, kailangan mong dumaan sa bawat elemento nang paisa-isa. Ito ay para sa isang Java iterator.

Ano ang isang Iterator sa Java

Ano ang isang iterator sa Java? Ito ay isang paraan ng pagtingin sa bawat elemento sa isang koleksyon. At sa pamamagitan ng koleksyon, ibig sabihin namin ang anumang bagay sa klase ng Collection . Kabilang dito ang:

• ArrayList
• HashSet
• LinkedHashSet
• LinkedList
• PriorityQueue
• Vector
• at marami pang iba…

Kasama rin dito ang iba't ibang interface para sa mga klaseng iyon, tulad ng Set , List , Queue , Dequeue , at Sorted Set , upang pangalanan ang ilan. Ang Iterator<E> ay ang paraan ng pampublikong interface ng Interface Iterator<E> klase. Ito ay dinala sa Java 1.2 at pinalitan ang Enumeration bilang isang paraan upang suriin ang mga sunud-sunod na elemento sa isang koleksyon.

Bakit Hindi Mo Dapat Gumamit Para sa Mga Loop bilang isang Iterator sa Java

Isa sa mga unang paraan na tinuturuan ang lahat na umulit sa pamamagitan ng isang koleksyon sa Java ay para sa isang loop. Mukhang ganito:

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]);
    }
  }
}

Ang output ay isang listahan na nagbabasa:

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

Ito ay may mga gamit, ngunit ano ang mangyayari kung ang koleksyon ay hindi nag-iimbak ng mga elemento sa isang index-based na system? Halimbawa, ang Set s ay walang order na normal. Kaya ipinapayong umalis sa pagsasanay ng paggamit ng for loop bilang isang iterator sa Java at magsanay gamit ang Iterator<E> class sa halip. Narito ang ilang mga halimbawa ng java iterator.

Paano gamitin ang Iterator sa Java

Narito ang ilang mga halimbawa kung paano gamitin ang iterator sa Java. Kapag ginagamit ang klase ng iterator, mayroong tatlong paraan upang tumawid sa isang koleksyon. Maaari kang gumamit ng while() loop, for() loop, at forEach() loop. Tandaan na ito para sa loop ay iba sa isa na napag-usapan natin dati. Narito ang tatlong magkakaibang mga halimbawa ng java iterator. Una, i-set up natin ang Collection para umulit.

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");
  }
}

Ito ay isang simpleng Koleksyon na binubuo ng isang ArrayList kung saan nag-load kami ng apat na item. Ngayon tingnan natin ang tatlong paraan ng paggamit ng klase ng Iterator upang lampasan ang ArrayList .

Habang() loop

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

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

Ang while() loop na ito ay gumagamit ng .hasNext() Boolean na paraan ng Iterator class upang tingnan kung may elemento sa hinaharap. Kung totoo ang precondition, magpapatuloy ito. Kung ito ay bumalik bilang false, pagkatapos ay ang loop ay nagtatapos. Ang pangunahing bahagi dito ay ang .hasNext() at ang .next() na mga pamamaraan ay parehong gumagawa ng paunang pagsusuri sa unang elemento. Kung ang Collection ay walang laman at walang unang elemento, ang pamamaraan ay nagbabalik ng false para sa .hasNext() at magtapon ng NoSuchElementException para sa .next() na pamamaraan.

Para sa loop

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

Mukhang mas tradisyonal ito para sa loop. Ginagamit nito ang .hasNext() na paraan bilang bahagi ng pagsuri at pagbabago ng kondisyon. Ang pagsisimula ay ang tawag sa Iterator.

Para sa: Bawat loop

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

Ang Para sa:Bawat loop ay para sa loop, ngunit kung hindi mo alam kung paano basahin ito, maaaring ito ay medyo nakakalito. Ang syntax ng isang For:Each loop ay para sa (data_type variableName : collectionName){ body} . This for: each loop does have a couple of drawbacks. Una, maaari lamang itong tumawid sa koleksyon sa isang direksyon. Pangalawa, kailangan mong umulit sa bawat elemento. Hindi mo maaaring laktawan ang alinman sa mga ito. Ngunit bilang isang maginhawang list iterator sa Java, ito ang pinakamahusay na opsyon. Sa kalamangan, ang para sa: bawat loop ay napakadaling basahin at kapag alam mo na ito, mahirap na magkamali. Kung nagtataka ka kung ano ang output ng tatlong mga loop ng iterator, pareho silang lahat:

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

Paano gumamit ng Iterator sa Java Para sa Mga Mapa

Ang mga mapa ay isang sikat na paraan upang mag-imbak ng data, ngunit dahil hindi nila pinalawak ang Koleksyon , hindi mo magagamit ang mga nakaraang iterator upang direktang tumawid sa isang mapa. Kaya paano ka gumagamit ng isang iterator sa Java upang dumaan sa Map s at HashMap s? Mayroong apat na mahusay na pamamaraan ng Java map iterator. Isa-isa nating sasakupin ang mga ito. Una, i-load natin ang isang mapa na may serye ng mga halaga.

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 Method: forEach(action)

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

Gumagamit ang paraang ito ng lambda expression para umulit. Ang lambda operator ay ang forEach() na pamamaraan, at ang katawan ay nagpi-print ng mga halaga. Gumagamit ito ng maramihang parameter na operator. Ito ang pinakamabilis at pinakamalinis na paraan para sa iterator ng mapa sa Java 8.

Java Hashmap Iterator Method: Para sa:Each() Loop

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

Ito ay gumagamit ng Para sa:Bawat syntax upang tawagan ang entrySet() na paraan upang ibalik ang isang set na may susi at halaga bilang mga elemento nito. Bukod pa rito, kapag ginagamit ang .Entry() na pamamaraan, ang mga bagay ay totoo lamang habang nangyayari ang pag-ulit na ito.

Java Hashmap Iterator Method: 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());
)

Ang pamamaraang ito ay muling nagko-convert sa Map sa isang set upang magamit ang Collections Iterator at mga pamamaraan. Para sa tatlong pamamaraan ng iterator na ito, ang pagbabalik ay ganito:

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);
}

Ibinabalik ng isang ito ang mga elemento sa ibang paraan. Ibabalik muna nito ang lahat ng Keys sa pagkakasunud-sunod at pagkatapos ay ang lahat ng Values:

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