Aide en utilisant la récursivité en Java

Question

J'ai une classe Group. Dans la classe j'ai deux champs, idGroupIdGroupGroup. Les groupes peuvent faire partie d'autres groupes. Ma classe Group est définie dans un HashMap<Integer,Integer>; la clé est IdGroupGroup et la valeur est idGroup. Je veux rechercher la carte pour un idGroup particulier; puis-je utiliser la récursivité pour cela?

class Group 
{ 

    int idGroupe 
    String word 
} 

HashMap<Integer,Integer> GroupeGroupe = new HashMap<Integer,Integer>(); 
GroupeGroupe.put(idGroupeGroupe, idGroupe) 

Answer 1

remet une question vague, je dois deviner beaucoup, mais peut-être c'est quelque chose comme ça vous cherchez:

import java.util.*; 

public class Test { 

    static Map<Integer, Integer> groups = new HashMap<Integer, Integer>(); 

    public static void main(String... args) { 
     groups.put(1, 2); 
     groups.put(2, 3); 
     groups.put(2, 4); 
     groups.put(4, 5); 
     System.out.println(searchFor(1, 5)); 
    } 

    private static String searchFor(int from, int target) { 

     // Target found? 
     if (from == target) return "" + target; 

     // Dead end? 
     if (!groups.containsKey(from)) return null; 

     // Recurse and try to find it from here. 
     String path = searchFor(groups.get(from), target); 
     return path == null ? null : from + " -> " + path; 
    } 
} 

Sortie: 1 -> 2 -> 4 -> 5

---

Ou quelque chose comme ceci:

static Map<Integer, Group> groups = new HashMap<Integer, Group>(); 

    public static void main(String... args) { 
     groups.put(0, new Group(1, "hello")); // (0: -)  -> (1: "hello") 
     groups.put(2, new Group(9, "!"));  // (2: "world") -> (9, "!") 
     groups.put(3, new Group(5, "bye")); // (3: -)  -> (5, "bye") 
     groups.put(1, new Group(2, "world")); // (1: "hello") -> (2: "world") 
     System.out.println(traverse(0)); 
    } 

    private static String traverse(int from) { 
     if (!groups.containsKey(from)) return ""; 

     String path = traverse(groups.get(from).idGroupe); 
     return path == null ? null : groups.get(from).word + " " + path; 
    } 
} 

qui imprime:

hello world ! 

Answer 2

Je ne suis pas sûr que je comprends votre question, mais je vais essayer de répondre. Est-ce que je vous ai bien compris si vous avez un java HashMap avec des entrées? Dans ce cas, vous avez une seule entrée pour chaque idGroupGroup (java api):

public V put(K key,V value) 

associés à la valeur spécifiée avec la clé spécifiée dans cette carte. Si la carte contenait précédemment un mappage pour la clé, l'ancienne valeur est remplacée.

si cela est très bien, et que vous voulez juste faire une récursion de tous les éléments que vous pouvez utiliser:

public Collection<V> values() 

Renvoie une vue Collection des valeurs contenues dans cette carte. La collection est adossée à la carte, donc les modifications apportées à la carte sont reflétées dans la collection, et vice versa. Si la carte est modifiée alors qu'une itération sur la collection est en cours (à l'exception de l'opération de suppression de l'itérateur), les résultats de l'itération ne sont pas définis. L'élimination collection prend en charge l'élément , qui supprime le mappage de la carte, par l'intermédiaire des Iterator.remove, Collection.remove, removeAll, retainAll et claires opérations correspondantes. Il ne prend pas en charge les opérations add ou addAll.

un coup d'oeil à: http://java.sun.com/javase/6/docs/api/java/util/HashMap.html

acclamations, Jørgen