Lijst van alle collecties

"Hallo Amigo."

"Hé Rishi."

"Ellie vertelde me dat je meer voorbeelden van collecties wilde. Ik zal je er een paar geven. Hier is een lijst met collecties en interfaces:"

"Hmm. Dat is best veel. Vier lijsten, drie sets en vier kaarten."

"Ja, het zijn allemaal verschillende implementaties van de List-, Set- en Map-interfaces."

"Wat is het verschil tussen deze implementaties?"

'Dat is precies waar we het vandaag over gaan hebben. Nog even geduld.'

"Heb je nog andere vragen?"

" Ik weet hoe ik een lijst op het scherm moet weergeven. Hoe kan ik een set of kaart weergeven?"

"De elementen van een lijst hebben een vaste volgorde, dus je kunt gewoon een index gebruiken om ze weer te geven. Voor een set of kaart is er geen specifieke volgorde. In feite kan de volgorde van hun elementen veranderen naarmate items worden verwijderd of nieuwe artikelen worden toegevoegd."

"Verbazingwekkend."

"Dit is de reden waarom speciale objecten, iterators genaamd, zijn uitgevonden om met collectie-elementen te werken. Ze laten je alle elementen in een collectie doorlopen, zelfs als ze alleen namen hebben in plaats van indexen (Map), of geen namen of indexen ( Set)."

"Hier zijn enkele voorbeelden:"

 public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

     // Get an iterator for the set
     Iterator&ltString> iterator = set.iterator();

    while (iterator.hasNext())        // Check if there is another element
    {
       // Get the current element and move to the next one
       String text = iterator.next();

        System.out.println(text);
    }
}
 

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

    Iterator&ltString> iterator = list.iterator();// Get an iterator for the list

    while (iterator.hasNext())      // Check if there is another element   
    {
        // Get the current element and move to the next one
        String text = iterator.next();

        System.out.println(text);
    }
}

public static void main(String[] args)
{
    // All elements are stored in pairs
    Map<String, String> map = new HashMap<String, String>();
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

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

   while (iterator.hasNext())
    {
        // Get a key-value pair
        Map.Entry<String, String> pair = iterator.next();
        String key = pair.getKey();            // Key
        String value = pair.getValue();        // Value
        System.out.println(key + ":" + value);
    }
}

"Wauw. Ik vraag me af wat dat allemaal betekent."

"Het is eigenlijk vrij eenvoudig. Eerst halen we een speciaal object, een iterator, uit de collectie. De iterator heeft slechts twee methoden.

1. De methode next() retourneert het volgende element in de verzameling.

2. De methode hasNext() controleert of er nog elementen zijn die niet zijn geretourneerd door next()."

'Oké. Ik denk dat het nu duidelijker wordt. Laat me proberen te herhalen wat ik begreep.'

"Dus... Eerst moeten we de methode iterator() op een verzameling aanroepen om dit magische iterator-object te krijgen."

"Vervolgens krijgen we elementen een voor een zolang er nog te krijgen zijn. We krijgen het volgende element in de collectie door next() aan te roepen, en we controleren of er nog elementen in de collectie zijn door hasNext() aan te roepen op de iterator. Klopt dat?"

"Ja, min of meer. Maar wacht op het goede deel."

"Java heeft een verkorte notatie voor het werken met iterators. Volgens het patroon van while en for is er nog een speciale verklaring toegevoegd: voor elke . Het wordt ook aangegeven met het trefwoord for ."

"Het for-each statement wordt alleen gebruikt voor het werken met collecties en containers. Het gebruikt impliciet een iterator, maar we zien alleen het geretourneerde element."

"Laat me je de lange en steno-manieren laten zien om met een iterator te werken:"

public static void main(String[] args)
{
  Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    Iterator&ltString> iterator = set.iterator();
  while (iterator.hasNext())
  {
    String text = iterator.next();
    System.out.println(text);
  }
}

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

   for (String text : set)   
    {
        System.out.println(text);
    }
}

"Merk op dat de rood of groen gemarkeerde woorden in het rechtergedeelte ontbreken. In feite zijn drie regels vervangen door één:"

Iterator&ltString> iterator = set.iterator();
while (iterator.hasNext())
{
    String text = iterator.next();

for (String text : set)

"Dit ziet er prachtig uit. Ik vind het veel leuker op deze manier."

"Laten we eens kijken naar de verkorte versie van de bovenstaande voorbeelden:"

public static void main(String[] args)
{
    Set&ltString> set = new HashSet&ltString>();
    set.add("Rain");
    set.add("In");
    set.add("Spain");

    for (String text : set)   
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    List&ltString> list = new ArrayList&ltString>();
    list.add("Rain");
    list.add("In");
    list.add("Spain");

     for (String text : list)        
    {
        System.out.println(text);
    }
}

public static void main(String[] args)
{
    Map<String, String> map = new HashMap<String, String>(); 
    map.put("first", "Rain");
    map.put("second", "In");
    map.put("third", "Spain");

    for (Map.Entry<String, String> pair : map.entrySet())
    {
        String key = pair.getKey();                      // Key
        String value = pair.getValue();                  // Value
        System.out.println(key + ":" + value);
    }
}

"Nu ben je aan het praten!"

"Ik ben blij dat je het leuk vond."