comparaison de Hashtables

Version imprimable

04/12/2010, 11h10
MattCand

comparaison de Hashtables

Bonjour^^
Je cherche à comparer les valeurs et les clés d'une Hashtable, elle-même contenue dans une Hashtable en tant que valeur (Hashtable<String, Hashtable>), avec d'autres Hashtables; Je ne sais pas du tout comment m'y prendre >< Need help =)
04/12/2010, 13h45
tchize_

tu pourrais préciser quels sont tes critères de comparaison et pourquoi la méthode equals ne te convient pas?
04/12/2010, 15h20
MattCand

En gros, je dois créer une méthode makeable (Hashtable ingrédients, Hashtable recette) qui doit retourner la liste des recettes possibles avec les ingrédients disponibles.

On a ingrédients<nom, quantité> et recette<nom, <ingédients qu'il faut> > mais je ne sais pas comment manipuler tout ça...

Le mieux serait ceci comme structure

List<Ingredient> (listes des ingrédients)

et Map<Recette,List<Ingredient>> (liste des recetes avec pour chaque une liste d'ingrédients)

ensuite tu parcoure tes recettes:

Code:

1
2
3
4
5
6
7
8
9
 
List<Recette> makeable(Map<Recette,List<Ingredient>>  recettes,  List<Ingredient> disponibles){
  List<Recette> result = new ArrayList<Recette>();
  for (Map.Entry<Recette,List<Ingredient>> element : recettes.entrySet()){
    if (disponible.containsAll(element.getValue())
        result.add(element.getKey());
  }
  return result;
}

autre option

Code:

1
2
3
4
5
6
7
8
9
 
List<Recette> makeable(List<Recette> recettes,  List<Ingredient> disponibles){
  List<Recette> result = new ArrayList<Recette>();
  for (Recette recette: recettes){
    if (disponible.containsAll(recette.getIngredients())
        result.add(recette);
  }
  return result;
}

05/12/2010, 10h51
MattCand

Merci pour ta réponse, mais je ne vois pas comment une liste pourrait stocker l'ingrédient PLUS la quantité disponible...
Ma Hashtable inventaire est comme ceci :
sucre 5
sel 2
oeufs 3

et et recette comme ça :
gateau : sucre 2 oeuf 1
omelette : sel 1 oeufs 2
05/12/2010, 13h21
tchize_

dans ce cas, tu fais deux boucles imbriquée et tu fais tout à la main.
05/12/2010, 13h31
bhamp0

Tu fais un objet "Nourriture", qui a 2 attributs :
* 1 String : l'ingrédient lui-même
* 1 Integer : la quantité

Après, tu fais un objet "Inventaire", qui a 2 attributs :
* 1 String : le nom du proprio du frigo :) [on ne fait jamais un programme que pour soi-même, il faut prévoir l'évolution]
* 1 List<Nourriture>

Et tu fais un objet "Recette", qui a 2 attributs :
* 1 String : le nom de la recette
* 1 List<Nourriture> : l'ensemble des ingrédients de la recette

Par contre, ce que je constate, c'est qu'il faudrait voir pour définir correctement ta comparaison, car faire un equals est légèrement bête : si on imagine que tu as 3 oeufs dans ton frigo, et que ta recette en demande 2, je pense qu'il faudrait répondre OK sur le fait qu'on peut faire la recette. Je verrais plutôt un "contains" plutôt qu'un "equals".
06/12/2010, 00h36
MattCand

Merci mais le problème est que je dois scrupuleusement respecter les entreées et la sortie de la méthode makeable, qui prend en paramètres deux Hashtables et qui renvoie une Arraylist.

Je suis désolé mais je ne comprends pas l'histoire de la double boucle imbriquée =S Pourrais-tu être plus concret?
06/12/2010, 10h04
tchize_

ben tu parcoure ta liste de recette (1ère boucle) et pour chaque recette tu parcoure la liste des ingrédients nécessaires (deuxième boucle), et pour chacun tu regarde si il y en a assez de dispo. Si pas tu passe à la recette suivante.

J'ai essayé mais il me renvoie pleins d'erreurs de compilation...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
Enumeration e = ingredients.elements();
Enumeration k = ingredients.keys();
Enumeration e1 = recettes.elements();
Enumeration k1 = recettes.keys();
 
 
 
 
 
while(e1.hasMoreElements()) {
			 Enumeration z = ((Hashtable) e1.nextElement()).keys();
			 Enumeration z1 = ((Hashtable) e1.nextElement()).elements();
			 while(z.hasMoreElements()) {
				 while(k.hasMoreElements()) {
 
					 if (z.nextElement().equals(k.nextElement())) {
						 if (Integer.parseInt(e1.nextElement().toString()) >= Integer.parseInt( z1.nextElement().toString())) {
							 System.out.println(e1.nextElement().toString());
 
						 }
					 }
 
				 }
 
 
 
				 //System.out.println(z.nextElement().toString());
			 } 
 
		}

Si la signature de makable ne t'est pas imposéé, tu peux utiliser cette implémentation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public List<Recette> makable(Map<String, Integer> ingrediantsDisponibles,
			List<Recette> recettes) {
		List<Recette> recettesRealisables = new LinkedList<Recette>();
 
		for (Recette recette : recettes) {
			if (recette.canBeDoneWith(ingrediantsDisponibles)) {
				recettesRealisables.add(recette);
			}
		}
 
		return recettesRealisables;
	}

Avec la classe recette:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
 
public class Recette {
	private String nom;
	private Map<String, Integer> ingrediants = new HashMap<String, Integer>();
 
	public Recette(String nom, Map<String, Integer> ingrediants) {
		super();
		this.nom = nom;
		this.ingrediants = ingrediants;
	}
 
	public void addIngrediant(String ingrediant, int quantite) {
		ingrediants.put(ingrediant, quantite);
	}
 
	/**
         * @return the nom
         */
	public String getNom() {
		return nom;
	}
 
	/**
         * @param nom
         *            the nom to set
         */
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	/**
         * @return the ingrediants
         */
	public Map<String, Integer> getIngrediants() {
		return ingrediants;
	}
 
	/**
         * @param ingrediants
         *            the ingrediants to set
         */
	public void setIngrediants(Map<String, Integer> ingrediants) {
		this.ingrediants = ingrediants;
	}
 
	public boolean canBeDoneWith(Map<String, Integer> ingrediantsDisponibles) {
		boolean canBeDone = true;
		Iterator<Entry<String, Integer>> iterator = ingrediants.entrySet()
				.iterator();
// Tant que la recette reste realisable
// On itère sur les ingrediants necessaires
		while (iterator.hasNext() && canBeDone) {
			Entry<String, Integer> ingrediantNecessaire = iterator.next();
 
// La recette est realisable si ...
			canBeDone = 
// ... on dispose des ingrediants necessaires
ingrediantsDisponibles.containsKey(ingrediantNecessaire.getKey()) &&
// ... en quantité suffisante
ingrediantsDisponibles.get(ingrediantNecessaire.getKey())>=ingrediantNecessaire.getValue(); 
		}
 
		return canBeDone;
	}
 
}

Le tout avec un semblant de test rapide

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/**
         * @param args
         */
	public static void main(String[] args) {
		Map<String, Integer> ingrediantsDansLeFrigo = new HashMap<String, Integer>() {
			{
				put("Persil", 4); 
				put("Oeuf", 5);
				put("Farine", 200); // 200g
				put("Lait", 400); // 4 briques de 1L
//				put("Beurre", 500);
			}
		};
 
		Recette crepes = new Recette("Crepes", new HashMap<String, Integer>() {
			{
				put("Oeuf", 2);
				put("Farine", 200);
				put("Lait", 100);
			}
		});
		Recette bechamel = new Recette("Sauce béchamel",
				new HashMap<String, Integer>() {
					{
						put("Beurre", 100);
						put("Farine", 100);
						put("Lait", 100);
					}
				});
 
		List<Recette> recettes = new ArrayList<Recette>(2);
		recettes.add(crepes);
		recettes.add(bechamel);
 
		List<Recette> makable = makable(ingrediantsDansLeFrigo,
				recettes);
		for (Recette recette : makable) {
			System.out.println(recette.getNom());
		}
 
	}