Lista de todas as coleções

"Olá, amigo."

"Ei, Rishi."

"Ellie me disse que você queria mais exemplos de coleções. Vou dar alguns. Aqui está uma lista de coleções e interfaces:"

"Hmm. Isso é bastante. Quatro listas, três conjuntos e quatro mapas."

"Sim, são todas implementações diferentes das interfaces List, Set e Map."

"Qual é a diferença entre essas implementações?"

"É exatamente sobre isso que vamos falar hoje. Apenas seja paciente."

"Você tem alguma outra pergunta?"

"Eu sei como exibir uma lista na tela. Como faço para exibir um Conjunto ou Mapa?"

"Os elementos de uma lista têm uma ordem definida, então você pode apenas usar um índice para exibi-los. Para um conjunto ou mapa, não há ordem específica. Na verdade, a ordem de seus elementos pode mudar à medida que os itens são excluídos ou novos itens são adicionados."

"Incrível."

"É por isso que objetos especiais, chamados iteradores , foram inventados para trabalhar com elementos de coleção. Eles permitem que você percorra todos os elementos de uma coleção, mesmo que tenham apenas nomes em vez de índices (Map), ou nem nomes nem índices ( Definir)."

"Aqui estão alguns exemplos:"

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

"Uau. Eu me pergunto o que tudo isso significa."

"É realmente muito simples. Primeiro, obtemos um objeto especial, um iterador, da coleção. O iterador tem apenas dois métodos.

1. O método next() retorna o próximo elemento da coleção.

2. O método hasNext() verifica se ainda existem elementos que não foram retornados por next()."

"OK. Acho que está ficando mais claro agora. Deixe-me tentar repetir para você o que eu entendi."

"Então... Primeiro, precisamos chamar o método iterator() em uma coleção para obter esse objeto iterador mágico."

"Em seguida, obtemos os elementos um por um, desde que haja algum para obter. Obtemos o próximo elemento na coleção chamando next() e verificamos se ainda há elementos na coleção chamando hasNext() no iterador. Está correto?"

"Sim, mais ou menos. Mas espere pela parte boa."

"Java possui notação abreviada para trabalhar com iteradores. Seguindo o padrão while e for , mais uma instrução especial foi adicionada: para cada . Também é indicado usando a palavra-chave for ."

"A instrução for-each é usada apenas para trabalhar com coleções e contêineres. Ela usa um iterador implicitamente, mas vemos apenas o elemento retornado."

"Deixe-me mostrar-lhe as formas de trabalhar com um iterador:"

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

"Observe que as palavras destacadas em vermelho ou verde estão ausentes na parte direita. Na verdade, três linhas são substituídas por uma:"

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

for (String text : set)

"Isso parece lindo. Eu gosto muito mais assim."

"Vamos ver a versão abreviada dos exemplos acima:"

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

"Agora você está falando!"

"Estou feliz que você gostou."