Lista de todas las colecciones

"Hola, amigo".

"Hola, Rishi".

"Ellie me dijo que querías más ejemplos de colecciones. Te daré algunos. Aquí hay una lista de colecciones e interfaces:"

"Hmm. Eso es bastante. Cuatro listas, tres conjuntos y cuatro mapas".

"Sí, todas son implementaciones diferentes de las interfaces List, Set y Map".

"¿Cuál es la diferencia entre estas implementaciones?"

"Eso es exactamente de lo que vamos a hablar hoy. Solo ten paciencia".

"¿Alguna otra pregunta?"

"Sé cómo mostrar una lista en la pantalla. ¿Cómo puedo mostrar un conjunto o un mapa?"

"Los elementos de una Lista tienen un orden establecido, por lo que solo puede usar un índice para mostrarlos. Para un Conjunto o Mapa, no hay un orden específico. De hecho, el orden de sus elementos puede cambiar a medida que se eliminan elementos o se crean nuevos. se agregan elementos".

"Asombroso."

"Es por eso que se inventaron objetos especiales, llamados iteradores, para trabajar con elementos de colección. Te permiten recorrer todos los elementos de una colección, incluso si solo tienen nombres en lugar de índices (mapa), o no tienen nombres ni índices ( Colocar)."

"Aquí hay unos ejemplos:"

 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. Me pregunto qué significa todo eso".

"En realidad, es bastante simple. Primero, obtenemos un objeto especial, un iterador, de la colección. El iterador tiene solo dos métodos.

1. El método next() devuelve el siguiente elemento de la colección.

2. El método hasNext() comprueba si todavía hay elementos que next() no ha devuelto".

"Está bien. Creo que ahora está más claro. Déjame tratar de repetirte lo que entendí".

"Entonces... Primero, necesitamos llamar al método iterator() en una colección para obtener este objeto iterador mágico".

"Luego obtenemos los elementos uno por uno siempre que quede alguno por obtener. Obtenemos el siguiente elemento de la colección llamando a next(), y verificamos si todavía hay elementos en la colección llamando a hasNext() en el iterador. ¿Es eso correcto?"

"Sí, más o menos. Pero espera la parte buena".

"Java tiene notación abreviada para trabajar con iteradores. Siguiendo el patrón de while y for , se ha agregado una declaración especial más: for each . También se indica usando la palabra clave for ".

"La declaración for-each solo se usa para trabajar con colecciones y contenedores. Usa un iterador implícitamente, pero solo vemos el elemento devuelto".

"Déjame mostrarte las formas abreviada y abreviada de trabajar con un 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);
    }
}

"Tenga en cuenta que las palabras resaltadas en rojo o verde están ausentes en la parte derecha. De hecho, tres líneas se reemplazan por una:"

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

for (String text : set)

"Esto se ve hermoso. Me gusta mucho más de esta manera".

"Veamos la versión abreviada de los ejemplos anteriores:"

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

"¡Ahora estas hablando!"

"Me alegra que te guste."