Elenco di tutte le collezioni

"Ciao, Amico."

"Ehi, Rishi."

"Ellie mi ha detto che volevi altri esempi di raccolte. Te ne darò alcuni. Ecco un elenco di raccolte e interfacce:"

"Hmm. È parecchio. Quattro liste, tre serie e quattro mappe."

"Sì, sono tutte diverse implementazioni delle interfacce List, Set e Map."

"Qual è la differenza tra queste implementazioni?"

"Questo è esattamente ciò di cui parleremo oggi. Sii paziente."

"Hai qualche altra domanda?"

"So come visualizzare un elenco sullo schermo. Come faccio a visualizzare un set o una mappa?"

"Gli elementi di un elenco hanno un ordine prestabilito, quindi puoi semplicemente utilizzare un indice per visualizzarli. Per un insieme o una mappa, non esiste un ordine specifico. In effetti, l'ordine dei loro elementi può cambiare man mano che gli elementi vengono eliminati o nuovi gli elementi vengono aggiunti."

"Sorprendente."

"Questo è il motivo per cui sono stati inventati oggetti speciali, chiamati iteratori , per lavorare con gli elementi della collezione. Ti permettono di passare attraverso tutti gli elementi di una collezione, anche se hanno solo nomi invece di indici (Map), o né nomi né indici ( Impostato)."

"Ecco alcuni esempi:"

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

"Wow. Mi chiedo cosa significhi tutto questo."

"In realtà è abbastanza semplice. Innanzitutto, otteniamo un oggetto speciale, un iteratore, dalla raccolta. L'iteratore ha solo due metodi.

1. Il metodo next() restituisce l'elemento successivo nella raccolta.

2. Il metodo hasNext() controlla se ci sono ancora elementi che non sono stati restituiti da next()."

"OK. Penso che ora stia diventando più chiaro. Lascia che ti ripeta quello che ho capito."

"Quindi... Per prima cosa, dobbiamo chiamare il metodo iterator() su una raccolta per ottenere questo oggetto iteratore magico."

"Quindi otteniamo gli elementi uno per uno finché ce ne sono ancora da ottenere. Otteniamo l'elemento successivo nella raccolta chiamando next() e controlliamo se ci sono ancora elementi nella raccolta chiamando hasNext() sul iteratore. È corretto?"

"Sì, più o meno. Ma aspetta il bello."

"Java ha una notazione abbreviata per lavorare con gli iteratori. Seguendo lo schema di while e for , è stata aggiunta un'altra istruzione speciale: for each . Viene indicata anche utilizzando la parola chiave for ."

"L'istruzione for-each viene utilizzata solo per lavorare con raccolte e contenitori. Utilizza implicitamente un iteratore, ma vediamo solo l'elemento restituito."

"Lascia che ti mostri i modi longhand e shorthand per lavorare con un iteratore:"

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

"Si noti che le parole evidenziate in rosso o in verde sono assenti nella parte destra. Infatti, tre righe sono sostituite da una:"

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

for (String text : set)

"Sembra stupendo. Mi piace molto di più così."

"Diamo un'occhiata alla versione abbreviata degli esempi precedenti:"

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

"Ora stai parlando!"

"Sono felice che ti sia piaciuto."