Programme fast-food: supprimer des éléments d'une ArrayList s'ils s'y trouvent

/!\Ce post sera mis à jour ne continu/!\

Bonjour à tous pour ma première sur ce forum



Le but de mon projet (dans le cadre de mes études) est de parvenir à simuler, de manière simplifiée, le fonctionnement d'un fast food.

Grâce au site du zero, et en particulier au tuto Java (dont j'ai acheté le livre :)), j'ai pu avancer dans ce projet.

Avancement du projet: [terminé] [en cours] [à faire]
-Permettre la création de nouveaux ingrédients que l'on ajoute à un stock d'ingrédients (méthode createIngredients())
-Permettre la création de nouveaux produits (simple et composé) que l'on ajoute à un objet qui recense les produits disponibles à la vente (méthode createProduits())
-Afficher la constitution d'un Produit_compose (méthode DecrisProduitCompose())
-Lors de la création d'un Produit_compose, il faut retirer les Ingredient utilisés pour cette création au stock d'ingrédients
-Mettre en place la partie "commande par un client"

-------------------------------------------------------------------

Un ingrédient est caractérisé par le fait qu'il n'est pas disponible à la commande mais intervient dans la préparation d'un produit_compose.
Ex*: tomate, steack, cornichon, ...
Un produit est caractérisé par le fait qu'il est disponible à la commande par un client.
Un produit_compose est un produit qui se compose de plusieurs Ingrédient.
Ex*: hamburger, glace 3 boules, ...
Un produit_simple est, comme son nom l'indique, un produit qui «*ne se compose que de lui-même*».
Ex*: frite, ketchup, soda, …

---------------------------------------------------------------------

Un petit diagramme UML pour vous montrer où j'en suis:




Petite description des classes/méthodes:


Classe Ingredient: Elle permet de créer de nouveaux ingrédients qui se caractérisent par leur nom et leur prix unitaire. On y trouve les méthodes get et set associées ainsi q'une méthode permettant la description d'un tel objet.


Classe Ingredients: Elle représente les ingrédients en stock. Ici, on utilise le pattern design Singleton pour s'assurer qu'elle ne pourra être instanciée qu'une seule fois pendant la durée de l'application. On y trouve la méthode createIngredients() qui va créer un certain nombre d'ingrédients identiques et les ajouter au stock d'ingrédients.

Classe Produit: Il s'agit d'une classe abstraite qui est la super-classe des deux classes suivantes et qui comporte les habituelles méthodes get et set pour le nom du produit et son prix.

Classe Produit_compose: C'est une sous-classe de Produit qui permet la création de nouveaux produits composés via une liste de Ingredient passée en paramètre. Elle comporte également une méthode DecrisProduitCompose() qui retourne une chaîne de caractère indiquant les Ingrédient qui composent le produit composé.

Classe Produit_simple: C'est une sous-classe de Produit qui permet la création de nouveaux produits simples.

Classe ProduitEnVente: Elle représente les produits disponibles à la vente. On utilise également ici le pattern design Singleton pour s'assurer que nous n'aurons à faire qu'à une seule instance. La méthode createProduits() permet de créer plusieurs Produit_simple ou Produit_compose et de les ajouter à la liste qui représente les produits disponibles à la vente.

Classe Test: C'est notre main!

[B]Les classes:[/B]

public class Ingredient {
 
	/**
	 * Variables d'instance.
	 */
	
    protected String nom_ingredient;
    protected double prix_unitaire;
 
    /**
     * Constructeur
     */
    
    Ingredient(String nom_ingredient, double prix_unitaire){
        this.nom_ingredient=nom_ingredient;
        this.prix_unitaire=prix_unitaire;
        
    }
 
   
    /**
     * Retourne le nom d'un produit.
     * @return nom d'un produit
     */
    
    public String getNom_ingredient(){
    	return this.nom_ingredient;
    }
    
    /**
     * Modifie le nom d'un ingredient.
     * @param nom_ingredient nom de l'ingredient
     */
    
    public void setNom_ingredient(String nom_ingredient){
    	this.nom_ingredient=nom_ingredient;
    }
    
    /**
     * Retourne le prix d'un ingredient.
     * @return prix de l'ingredient 
     */
    
    public double getPrix_unitaire(){
    	return this.prix_unitaire;
    }
    
    /**
     * Modifie le prix d'un ingredient.
     * @param prix_unitaire prix de l'ingredient
     */
    
    public void setPrix_unitaire(int prix_unitaire){
    	this.prix_unitaire=prix_unitaire;
    }
    
    /**
     * Decris l'ingredient
     * @return description de l'ingredient
     */
    
    public String DecrisIngredient(){
        return "L'ingrédient "+this.nom_ingredient+" est au prix unitaire de "+this.prix_unitaire+" €";
    }
    
    
    
}

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
 
/**
 * Permet de créer de nouveaux ingrédients.
 */
public final class Ingredients {
 
    /**
     * Singleton statique qui permet de ne référencer qu'une seule instance
     * de la classe Ingredients.
     */
    private static Ingredients ingredients ;
 
    /**
     * Liste de tous les ingrédients créés par l'intermédiaire de l'instance
     * unique d'ingrédients.
     */
    private static List<Ingredient> stockIngredient;
 
    /**
     * Constructeur privé interdisant son instanciation à l'extérieur de la classe.
     */
    private  Ingredients() {
        Ingredients.stockIngredient = new ArrayList<Ingredient>();
    }
    
    public static Ingredients getInstance(){
    	if (ingredients==null){
    		ingredients=new Ingredients();
    	}
    	return ingredients;
    }
    
    
    
    public static List<Ingredient> getStockIngredients(){
    	return stockIngredient;
    }
    
    
 
    /**
     * Crée une nouvelle liste d'ingrédients.
     * @param ingredientType nom des ingrédients
     * @param price prix des ingrédients créés
     * @param quantity nombre d'ingrédients à créer
     * @return liste de tous les ingrédients créés
     */
    public static List<Ingredient> createIngredients(String ingredientType, double price, int quantity) {
        List<Ingredient> newIngredients = new ArrayList<Ingredient>();
        for (int i = 0; i < quantity; i++) {
            newIngredients.add(new Ingredient(ingredientType, price));            
        }
        System.out.println(quantity+" "+ ingredientType+" ont été ajoutés au stock");
        Ingredients.stockIngredient.addAll(newIngredients);
        return newIngredients;
    }
    
    
    /**
     * Prendre un(des) ingrédient(s) du stock et les supprimer.
     * @param nom_ingredient nom des ingrédients
     * @param quantity nombre d'ingrédients à prendre du stock
     * @return liste de tous les ingrédients pris du stock
     */
    	        
    public static List<Ingredient> PrendreIngredientFromStockAndDeleteFromStock(String nom_ingredient, int quantity ){
    	List<Ingredient> liste_ingredient_pris=new ArrayList<Ingredient>();
    	int j = 0;
    	for (Ingredient ingred : Ingredients.stockIngredient){
    		if (nom_ingredient.equals(ingred.getNom_ingredient()) &&  j<quantity){
    			liste_ingredient_pris.add(ingred);
    			j++;
    	        }
    	}
    	if (j!=quantity){
    		int diff=quantity-j;
    		System.out.println("Il manque "+diff+" "+nom_ingredient+" pour pouvoir composé le produit désiré");
    	}
    	Ingredients.stockIngredient.removeAll(liste_ingredient_pris);
    	return liste_ingredient_pris;
	   
   }
    
    /**
     * Decrire le stock d'ingrédients
          */
    
    public static void DecrisStock(){
    	String comp="Le stock d'ingrédients se composent de:";
    	for (Ingredient ing : stockIngredient){
    		comp = comp +"\n"+"-"+ ing.getNom_ingredient();
    		}
    	System.out.println(comp);
    	
    }
    
    
}

/**
 * Classe abstraite qui "définit" un produit.
 */
public class Produit {
	
	/**
	 * Variables d'instance.
	 */
	
    protected String nom_produit;
    protected double prix_produit;
    
    /**
     * Constructeur
     */
    
    protected Produit(String nom_produit, double prix_produit) {
         this.nom_produit=nom_produit;
        this.prix_produit=prix_produit;
    }
    
    protected Produit(){
    	
    }
    
    /**
     * Retourne le nom d'un produit.
     * @return nom d'un produit
     */
    
   public String getNom_produit(){
    	return this.nom_produit;
    }
   
   /**
    * Modifie le nom d'un produit.
    * @param nom_produit nom du produit
    */
   
    public void setNom_produit(String nom_produit){
    	this.nom_produit=nom_produit;
    }
    
    /**
     * Retourne le prix d'un produit.
     * @return prix du produit
     */
    
    public double getPrix_produit(){
    	return this.prix_produit;
    }
    
    /**
     * Modifie le prix d'un produit.
     * @param prix_produit prix du produit
     */
    
    public void setPrix_produit(double prix_produit){
    	this.prix_produit=prix_produit;
    }
    
    
}

import java.util.Arrays;
import java.util.List;

/**
 * Classe qui définit un produit compose.
 */

public class Produit_compose extends Produit {
	
	/**
	 * liste des ingrédients qui entrent dans la composition d'un produit compose.
	 */
	
    protected List<Ingredient> liste_ingredient;
    
    /**
	 * Constructeur
	 */
    
    Produit_compose(String nom_produit, double prix_produit, List<Ingredient>liste_ingredient) {
        super(nom_produit, prix_produit);
        this.liste_ingredient = liste_ingredient;
                 	 
         }
    
    /**
     * Decris un produit compose.
     * @return description du produit compose
     */
    
        public String DecrisProduitCompose() {
    	String composition="";
    	   	 	for (Ingredient ing : this.liste_ingredient){
    	   	 		composition= composition + ing.getNom_ingredient()+"\n ";
    	}
    		return  composition;
    		
    		
    		
    	}
    	
    }

/**
 * Classe qui définit un produit simple.
 */

public class Produit_simple extends Produit {
	
	/**
	 * Constructeur
	 */
	
    public Produit_simple(String nom_produit, double prix_produit) {
        super(nom_produit, prix_produit);
        
    }
}

import java.util.ArrayList;
import java.util.List;
 
/**
 * Référence et créée de nouveaux produits.
 */
public final class ProduitsEnVente {
 
    /**
     * Singleton de ProduitsEnVente utilisé pour référencer de manière unique
     * les produits créés par le système.
     */
    private static ProduitsEnVente produits = new ProduitsEnVente();
 
    /**
     * Liste des produits créés par ProduitsEnVente.
     */
    private static List<Produit> products;
 
    /**
     * Constructeur privé qui permet à la classe de ne pas pouvoir être
     * instanciée.
     */
    private ProduitsEnVente() {
        products = new ArrayList<Produit>();
    }
    
    public static ProduitsEnVente getInstance(){
    	if (produits==null){
    		produits=new ProduitsEnVente();
    	}
    	return produits;
    }
 
    /**
     * Crée une liste de nouveaux Produit_simple.
     * @param productName nom des produits à créer
     * @param price prix des produits
     * @param quantité nom de Produit_simple à créer
     */
    public static List<Produit_simple> createProduits(String productName, double price, int quantity) {
        List<Produit_simple> newProducts = new ArrayList<Produit_simple>();
        for (int i = 0; i < quantity; i++) {
            newProducts.add(new Produit_simple(productName, price));
            
        }
        System.out.println(quantity+" "+productName+" sont dorénavant disponibles à la commande");
        produits.products.addAll(newProducts);
        return newProducts;
    }
 
    /**
     * Crée une liste de nouveaux Produit_simple.
     * @param productName nom des produits à créer
     * @param price prix des produits
     * @param quantite quantite du même produit compose à créer
     * @param ingredients liste des ingrédients necessaire à la préparation du produit compose
     * @return liste des nouveaux produits identiquement créés.
     */
    public static List<Produit_compose> createProduits(String productName, double price, int quantite, List<Ingredient>ingredients) {
    	// Creation d'un Produit temporaire qui sert simplement à appliquer la méthode DecrisProduitCompose (comme on peut le voir, 
    	//il n'est pas ajouté à newproducts)
        List<Produit_compose> newProducts = new ArrayList<Produit_compose>();
        Produit_compose temp = new Produit_compose(productName, price, ingredients);
         for (int i = 0; i < quantite; i++) {
            newProducts.add(new Produit_compose(productName, price, ingredients));
            Ingredients.getInstance();
            Ingredients.getStockIngredients().remove(ingredients);
                        	
            }
                
        System.out.println(quantite+" "+productName+" ont été préparés en cuisine et sont disponible à la commande");
        //System.out.println("Un "+productName+" se compose de:\n"+ temp.DecrisProduitCompose());
        produits.products.addAll(newProducts);
        return newProducts;
        
        
    }
    
    public static List<Produit> getProducts(){
    	return products;
    	
    }
    
    public static void DecrisStock(){
    	String compo = "Le stock de produits est : ";
    	
    	for (Produit prod : products){
    		compo = compo +" "+ prod.getNom_produit();
    	}
    	System.out.println(compo);
    	
    }
    public static Produit RechercherProduit(String nom_produit){
    	Produit temp = new Produit();
    	temp = null;
    	   	for (Produit prod : products){
    		int i=0;
    		if (nom_produit==prod.getNom_produit() && i<1){
    			i++;
    			temp=prod;
    			}
       	}
    	   	if (temp != null) {
    	   		System.out.println("Le produit a été trouvé");
    	   		}
    	   	else { 
    	   		System.out.println("Le produit n'a pas été trouvé!!!");
    	   		}
    	   	return temp;
    }
}

import java.util.ArrayList;
import java.util.List;
public class Commande {
	
	
	
	private List<Produit> produits_commandes;
	
	public Commande() {
		produits_commandes = new ArrayList<Produit>();
	}
	public List<Produit> CommanderProduits(String nom_client, List<String>produits) {
		List<Produit> OrderedProducts = new ArrayList<Produit>();
		int i=0;
		for (String prod : produits){
			i=0;
			ProduitsEnVente.getInstance();
			for (Produit prodbis : ProduitsEnVente.getProducts()){
			
			if (prod==prodbis.getNom_produit() && i<1){
				i++;
				OrderedProducts.add(prodbis);
			}
			}
						}
		ProduitsEnVente.getInstance();
		ProduitsEnVente.getProducts().removeAll(OrderedProducts);
		String compo = new String();
		for (Produit prod2 : OrderedProducts){
			compo = compo +" "+prod2.getNom_produit();
					}
		
		System.out.println("Mr "+nom_client+" vient de passer une commande: : "+compo+"");
		return OrderedProducts;
	}
}

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;


public class Test {
 
	public static void main(String[] args) {
           Fenetre fen = new Fenetre();
			Ingredients.getInstance();
			ProduitsEnVente.getInstance();
			
		// On crée une liste composée de 4 tomates 
        List<Ingredient> tomates = Ingredients.createIngredients("tomate", 0.5, 4);
        // Description d'une tomate
        System.out.println(tomates.get(0).DecrisIngredient());
        // On rajoute 0 tomates 
        tomates.addAll(Ingredients.createIngredients("tomate", 0.5, 0));
        // On ajoute 4 steacks
        List<Ingredient> steacks = Ingredients.createIngredients("steack", 2, 2);
        System.out.println(steacks.get(0).DecrisIngredient());
        List<Ingredient> cornichons = Ingredients.createIngredients("cornichon", 0.2, 6);
        Ingredients.DecrisStock();
       
        
        // On crée une liste d'ingrédients nécessaires à la préparation d'un seul BigMac
        List<Ingredient> ingredients = new ArrayList<Ingredient>();
        //On y ajoute 2 tomates
        ingredients.addAll(Ingredients.PrendreIngredientFromStockAndDeleteFromStock( "tomate", 2 ));
        //... puis 1 steack...
        ingredients.addAll(Ingredients.PrendreIngredientFromStockAndDeleteFromStock( "steack", 1 ));
        ingredients.addAll(Ingredients.PrendreIngredientFromStockAndDeleteFromStock( "cornichon", 4 ));
        Ingredients.DecrisStock();
        
        // On crée une liste d'ingrédients nécessaires à la préparation d'un CheeseBurger
        //List<Ingredient> ingredients2 = Ingredients.createIngredients("cornichon", .3, 2);
       // ingredients2.addAll(Ingredients.createIngredients("tomate", .5, 1));
        //ingredients2.addAll(Ingredients.createIngredients("steack", 1, 1));
        //ingredients2.addAll(Ingredients.createIngredients("cheddar", 1, 2));
        // On crée 5 BigMacs qui sont automatiquement ajoutés aux produits disponibles à la vente
        List<Produit_compose> BigMacs = ProduitsEnVente.createProduits("Big Mac", 4.5, 3, ingredients);
        //// On crée 3 CheeseBurgers qui sont automatiquement ajoutés aux produits disponibles à la vente
        //List<Produit_compose> CheeseBurgers = ProduitsEnVente.createProduits("Cheeseburger", 4.5, 3, ingredients2.toArray(new Ingredient[ingredients2.size()]));
        // On crée une liste de 12 frites qui sont automatiquement ajoutées aux produits disponibles à la vente
        List<Produit_simple> Frites = ProduitsEnVente.createProduits("frite", 4.5, 12);
      //  Ingredients.DecrisStock();
        ProduitsEnVente.getInstance();
        ProduitsEnVente.DecrisStock();
        List<String> produits = new ArrayList<String>();
        
        produits.add("frite");
        produits.add("Big Mac");
        produits.add("frite");
        
        Commande com1 = new Commande();
        com1.CommanderProduits("Albert", produits);
        ProduitsEnVente.getInstance();
        ProduitsEnVente.DecrisStock();
        
    }
 
}

Voilà le résultat du programme:

Citation : neon29

4 tomate ont été ajoutés au stock
L'ingrédient tomate est au prix unitaire de 0.5 €
0 tomate ont été ajoutés au stock
2 steack ont été ajoutés au stock
L'ingrédient steack est au prix unitaire de 2.0 €
6 cornichon ont été ajoutés au stock
Le stock d'ingrédients se composent de:
-tomate
-tomate
-tomate
-tomate
-steack
-steack
-cornichon
-cornichon
-cornichon
-cornichon
-cornichon
-cornichon
Le stock d'ingrédients se composent de:
-tomate
-tomate
-steack
-cornichon
-cornichon
3 Big Mac ont été préparés en cuisine et sont disponible à la commande
12 frite sont dorénavant disponibles à la commande
Le stock de produits est : Big Mac Big Mac Big Mac frite frite frite frite frite frite frite frite frite frite frite frite
Mr Florian vient de passer une commande: : frite Big Mac frite
Le stock de produits est : Big Mac Big Mac frite frite frite frite frite frite frite frite frite frite frite

Alors mon problème vient de la méthode CommanderProduits(). En effet, quand je lui demande de commander 2 produits différents (par exemple frite et Big Mac) il n'y a pas de soucis. En revanche comme on peut voir dans Test, Lorsque je commande 1 frite + 1 frite + 1 Big Mac, les trois produits sont ajoutés à ma commande, mais seuls 1 frite et 1 Big Mac sont retirés du stock de produit. Le problème vient peut-être du fait que 2 objets frite ont le même nom, mais je vois pas comment y remédier.
Si quelqu'un a remarqué une subtilité que je n'aurai pas vu merci de me le signaler

Je vois pourtant pas ce qui pose problème!
Si quelqu'un a une idée du problème je suis preneur!

Bonne journée!

J'ai l'impression que ce tuto pourrait t'être très utile : http://www.siteduzero.com/tutoriel-3-3 [...] n-python.html

Ah ouai je vais voir çà merci.
Autrement pour ma "méthode" à moi d'où peut venir l'erreur?

Salut, ici il y une concurrence Exception car tu supprime un element alors que tu boucle sur la liste tu ne peut pas faire ça.
essaye de remplacer par ça ta boucle d'ajout suppression des ingredients:

List<Ingredient> liste_ingredient_pris=new ArrayList<Ingredient>();
    	int j = 0;
    	for (Ingredient ingred : Ingredients.stockIngredient){
    		if (nom_ingredient.equals(ingred.getNom_ingredient()) &&  j<quantity){
    			liste_ingredient_pris.add(ingred);
    			j++;
    	        }
    	}
    	Ingredients.stockIngredient.removeAll(liste_ingredient_pris);
    	return liste_ingredient_pris;

Bonjour,

Comme son nom l'indique, ce forum est dédié aux problèmes de développements sur smartphones et tablettes. Vous n'êtes pas sans savoir que les modèles sont nombreux et que les développements sont très différents d'un OS à l'autre. Aussi, il est obligatoire d'ajouter une balise au titre de son sujet afin de bien cadrer le problème.

Exemples de titres corrects :

• [iPhone] Problème de curseurs
• [Android] Faire un jeu

Exemples de titres incorrects :

• Problème de curseurs
• Faire un jeu
• ca marche pa

Étant donné que ton message est par ailleurs bien présenté, je t'invite à modifier le titre du sujet pour le clarifier.

De plus, le titre idéal devrait résumer ton problème ou ta question en une petite phrase. Voici quelques liens pour t'aider à choisir au mieux ton titre :

• Bien poster un topic dans le forum programmation
• Bien poster un topic dans le forum recrutements pour vos projets

Si tu es l'auteur du topic, tu peux uniquement le changer en éditant le premier post du topic à l'aide de l'icône .

Attention : merci de modifier ton titre dans les plus brefs délais, sans quoi le sujet sera fermé.

Merci de ta compréhension

En revanche, il y a peut-être eu une maladresse de ma part: quand j'ai mis "application" je l'entendais au sens large et non pas application dans le sens Android ou autre. Donc si c'est possible de le re-déplacer dans la catégorie initiale

Et merci ninlock çà marche nickel çà:

List<Ingredient> liste_ingredient_pris=new ArrayList<Ingredient>();
    	int j = 0;
    	for (Ingredient ingred : Ingredients.stockIngredient){
    		if (nom_ingredient.equals(ingred.getNom_ingredient()) &&  j<quantity){
    			liste_ingredient_pris.add(ingred);
    			j++;
    	        }
    	}
    	Ingredients.stockIngredient.removeAll(liste_ingredient_pris);
    	return liste_ingredient_pris;

J'ai pas trop compris pourquoi ton code marche et pas le mien...

Voilà mon problème comme expliqué dans le 1er post:

Ma classe Commande:

import java.util.ArrayList;
import java.util.List;
public class Commande {
	
	
	
	private List<Produit> produits_commandes;
	
	public Commande() {
		produits_commandes = new ArrayList<Produit>();
	}
	public List<Produit> CommanderProduits(String nom_client, List<String>produits) {
		List<Produit> OrderedProducts = new ArrayList<Produit>();
		int i=0;
		for (String prod : produits){
			i=0;
			ProduitsEnVente.getInstance();
			for (Produit prodbis : ProduitsEnVente.getProducts()){
			
			if (prod==prodbis.getNom_produit() && i<1){
				i++;
				OrderedProducts.add(prodbis);
			}
			}
						}
		ProduitsEnVente.getInstance();
		ProduitsEnVente.getProducts().removeAll(OrderedProducts);
		String compo = new String();
		for (Produit prod2 : OrderedProducts){
			compo = compo +" "+prod2.getNom_produit();
					}
		
		System.out.println("Mr "+nom_client+" vient de passer une commande: : "+compo+"");
		return OrderedProducts;
	}
}

Mon main:

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;


public class Test {
 
	public static void main(String[] args) {
           Fenetre fen = new Fenetre();
			Ingredients.getInstance();
			ProduitsEnVente.getInstance();
			
		// On crée une liste composée de 4 tomates 
        List<Ingredient> tomates = Ingredients.createIngredients("tomate", 0.5, 4);
        // Description d'une tomate
        System.out.println(tomates.get(0).DecrisIngredient());
        // On rajoute 0 tomates 
        tomates.addAll(Ingredients.createIngredients("tomate", 0.5, 0));
        // On ajoute 4 steacks
        List<Ingredient> steacks = Ingredients.createIngredients("steack", 2, 2);
        System.out.println(steacks.get(0).DecrisIngredient());
        List<Ingredient> cornichons = Ingredients.createIngredients("cornichon", 0.2, 6);
        Ingredients.DecrisStock();
       
        
        // On crée une liste d'ingrédients nécessaires à la préparation d'un seul BigMac
        List<Ingredient> ingredients = new ArrayList<Ingredient>();
        //On y ajoute 2 tomates
        ingredients.addAll(Ingredients.PrendreIngredientFromStockAndDeleteFromStock( "tomate", 2 ));
        //... puis 1 steack...
        ingredients.addAll(Ingredients.PrendreIngredientFromStockAndDeleteFromStock( "steack", 1 ));
        ingredients.addAll(Ingredients.PrendreIngredientFromStockAndDeleteFromStock( "cornichon", 4 ));
        Ingredients.DecrisStock();
        
        // On crée une liste d'ingrédients nécessaires à la préparation d'un CheeseBurger
        //List<Ingredient> ingredients2 = Ingredients.createIngredients("cornichon", .3, 2);
       // ingredients2.addAll(Ingredients.createIngredients("tomate", .5, 1));
        //ingredients2.addAll(Ingredients.createIngredients("steack", 1, 1));
        //ingredients2.addAll(Ingredients.createIngredients("cheddar", 1, 2));
        // On crée 5 BigMacs qui sont automatiquement ajoutés aux produits disponibles à la vente
        List<Produit_compose> BigMacs = ProduitsEnVente.createProduits("Big Mac", 4.5, 3, ingredients);
        //// On crée 3 CheeseBurgers qui sont automatiquement ajoutés aux produits disponibles à la vente
        //List<Produit_compose> CheeseBurgers = ProduitsEnVente.createProduits("Cheeseburger", 4.5, 3, ingredients2.toArray(new Ingredient[ingredients2.size()]));
        // On crée une liste de 12 frites qui sont automatiquement ajoutées aux produits disponibles à la vente
        List<Produit_simple> Frites = ProduitsEnVente.createProduits("frite", 4.5, 12);
      //  Ingredients.DecrisStock();
        ProduitsEnVente.getInstance();
        ProduitsEnVente.DecrisStock();
        List<String> produits = new ArrayList<String>();
        
        produits.add("frite");
        produits.add("Big Mac");
        produits.add("frite");
        
        Commande com1 = new Commande();
        com1.CommanderProduits("Albert", produits);
        ProduitsEnVente.getInstance();
        ProduitsEnVente.DecrisStock();
        
    }
 
}

Résultat:

Citation : neon29

4 tomate ont été ajoutés au stock
L'ingrédient tomate est au prix unitaire de 0.5 €
0 tomate ont été ajoutés au stock
2 steack ont été ajoutés au stock
L'ingrédient steack est au prix unitaire de 2.0 €
6 cornichon ont été ajoutés au stock
Le stock d'ingrédients se composent de:
-tomate
-tomate
-tomate
-tomate
-steack
-steack
-cornichon
-cornichon
-cornichon
-cornichon
-cornichon
-cornichon
Le stock d'ingrédients se composent de:
-tomate
-tomate
-steack
-cornichon
-cornichon
3 Big Mac ont été préparés en cuisine et sont disponible à la commande
12 frite sont dorénavant disponibles à la commande
Le stock de produits est : Big Mac Big Mac Big Mac frite frite frite frite frite frite frite frite frite frite frite frite
Mr Florian vient de passer une commande: : frite Big Mac frite ok c'est ce qui est commandé
Le stock de produits est : Big Mac Big Mac frite frite frite frite frite frite frite frite frite frite frite Seuls 1 Big Mac et 1 frite ont été retirés du stock de produits

Le problème vient donc du fait qu'en commandant 1 frite + 1 frite + 1 Big Mac ces éléments sont bien ajoutés à ma commande mais seuls 1 frite et 1 Big Mac sont retirés du stock de produits. En gros il peut me retirer qu'un seul objet ayant le même nom.
Si quelqu'un voit où çà cloche je prends