Liste de toutes les collections

« Salut, Amigo. »

« Bonjour Rishi. »

« Ellie m'a dit que tu voulais plus d'exemples de collections. Je vais t'en donner quelques-uns. Voici une liste de collections et d'interfaces : »

« Hmm. Ça en fait beaucoup. Je compte quatre List, trois Set et quatre Map. »

« Oui, toutes ces classes sont des implémentations différentes des interfaces List, Set et Map. »

« Quelle est la différence entre toutes ces implémentations ? »

« C'est exactement ce dont nous allons parler aujourd'hui. Un peu de patience. »

« Est-ce que tu as d'autres questions ? »

« Je sais comment afficher une liste à l'écran. Comment afficher un Set ou une Map ? »

« Les éléments d'une classe List ont un ordre défini, et tu peux donc simplement utiliser un indice pour les afficher. Pour un Set ou une Map, il n'y a pas d'ordre spécifique. En fait, l'ordre de leurs éléments peut changer lorsque des éléments sont supprimés ou que nouveaux sont ajoutés. »

« Génial. »

« Voilà pourquoi des objets spéciaux, appelés itérateurs, ont été inventés pour travailler avec les éléments des collections. Ils vous permettent de passer en revue tous les éléments d'une collection, même s'ils n'ont que des noms au lieu d'indices (Map), ou ni nom ni indice (Set). »

« Voici quelques exemples : »

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

« Ouah. Je me demande ce que tout cela veut dire. »

« C'est très simple, en fait. Tout d'abord, nous récupérons un objet spécial, un itérateur, à partir de la collection. L'itérateur n'a que deux méthodes.

1. La méthode next() renvoie l'élément suivant dans la collection.

2. La méthode hasNext() vérifie s'il reste des éléments qui n'ont pas encore été renvoyés par next(). »

« OK. Je crois que ça commence à être plus clair. Je vais essayer de répéter pour m'assurer d'avoir compris. »

« Donc... Tout d'abord, nous devons appeler la méthode iterator() sur une collection pour obtenir cet objet magique appelé itérateur. »

« Ensuite, nous récupérons les éléments un par un tant qu'il en reste à récupérer. Nous obtenons l'élément suivant dans la collection en appelant next(), et nous vérifions s'il y a encore des éléments dans la collection en appelant hasNext() sur l'itérateur. C'est bien ça ? »

« Oui, plus ou moins. Mais je ne t'ai pas dit le meilleur. »

« Java a une abréviation pour travailler avec les itérateurs. Sur le même modèle que while et for, une autre instruction spéciale a été ajoutée : for each. Elle est également indiquée par le mot-clé for. »

« L'instruction for-each est utilisée uniquement pour travailler avec les collections et les conteneurs. Elle utilise un itérateur implicitement, mais nous ne voyons que l'élément renvoyé. »

« Laisse-moi te montrer les façons courte et longue de travailler avec un itérateur : »

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

« Note que les mots soulignés en rouge ou vert sont absents dans la partie droite. En fait, trois lignes sont remplacées par une seule : »

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

for (String text : set)

« C'est magnifique. J'aime beaucoup mieux ça comme ça. »

« Jetons un œil à la version courte des exemples ci-dessus : »

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

« Maintenant ça me parle ! »

« Je suis contente que cela te plaise. »