aide avec java hash map

Question

quelqu'un peut-il s'il vous plaît expliquer ce qui se passe dans le code ci-dessous et comment il se termine par 36?

grâce

modifier par Amir Rachum

public class HashMap2009 { 
    public static void main (String[] args) { 
     Map<String, Integer> myMap2009 = 
      new HashMap<String, Integer>(); 
     myMap2009.put("one", new Integer(1)); 
     myMap2009.put("three", new Integer(3)); 
     myMap2009.put("five", new Integer(5)); 
     myMap2009.put("seven", new Integer(7)); 
     myMap2009.put("nine", new Integer(9)); 
     System.out.println(oddOne(myMap2009)); 
    } 
    private static int oddOne(Map<String, Integer> myMap2009) { 
     if (myMap2009.isEmpty()) 
      return 11; 
     else { 
      Set<String> st = myMap2009.keySet(); 
      String key = st.iterator().next(); 
      int num = myMap2009.get(key); 
      myMap2009.remove(key); 
      return num + oddOne(myMap2009); 
     } 
    } 
} 

Answer 1

Ceci est un exemple simple de recursion, qui se traduit par l'ajout de toutes les clés dans la carte un par un et quand la carte est vide , il ajoute un autre 11. Cela résume jusqu'à 36.

Answer 2

C'est une fonction recursive, qui chaque fois qu'il est appelé, ajoutez la valeur du premier élément dans la carte, puis supprimez-le.

Si la carte est vide, il retourne 11

Alors: 9+7+5+3+1+11 = (9,7,5,3,1 pour chaque valeur de la carte et 11 quand il est vide)

BTW, cela me semble une façon terrible pour enseigner récursion (parce que la carte crée trop de bruit)

un simple (et je pense que plus efficace) façon aurait été:

import java.util.ArrayList; 
import java.util.List; 
import java.util.Iterator; 
public class ArrayList2009 { 
    public static void main(String [] args) { 
     List<Integer> list = new ArrayList<Integer>(); 
     list.add(1); 
     list.add(3); 
     list.add(5); 
     list.add(7); 
     list.add(9); 
     System.out.println(addOne(list));       
    } 
    private static int addOne(List<Integer> list){ 
     if (list.isEmpty()) { 
      return 11; 
     } else { 
      Iterator<Integer> i = list.iterator(); 
      int num = i.next(); 
      i.remove(); 
      return num + addOne(list); 
     } 
    } 
} 

Ce qui fait exactement la même chose, mais introduit moins de bruit car l'interface List est plus facile à comprendre.

Answer 3

Lorsque vous appelez Oddone il se

• le premier numéro
• supprimer le numéro
• ajouter au résultat de Oddone (avec le numéro enlevé)

ce répète jusqu'à ce vide whne oddOne retour 11

donc nous nous retrouvons avec

1 + (3 + (5 + (7 + (9 + 11)))) = 36

effectivement l'ordre sera e tout pêle-mêle comme il est un hashmap mais cela n'a pas d'influence sur l'ajout de numéros

Answer 4

Vous effectuez des appels récursifs en supprimant un élément de la carte par appel.

Vous pouvez commencer avec num == 1 (une carte est non ordonnée) et vous l'enlevez de votre carte. Ensuite, vous faites l'appel récursif, qui vous donne num == 3. Cela continue jusqu'à ce que votre carte soit vide, ce qui entraîne 1 + 3 + 5 + 7 + 9, et 11 supplémentaires pour votre carte vide.

Jetez un oeil à la récursivité: http://en.wikipedia.org/wiki/Recursion