Discussion :

[kahya]

Bonjour à tous! Je vais essayer d'être la plus précise possible : J'ai des fichiers .txt que je dois parcourir, lire, et avec les informations lues, je dois construire des objets et les serialiser ensuite. J'ai notament un fichier qui fait 54 000 lignes. Pour situer le contexte, ce fichier est l'enregistrement des commandes. Chaque ligne représente la vente d'un lot (ou d'une partie de lot) pour un article donnée et pour une commande donnée. Je dois donc créer ces objets lots, articles et commande. Une commande contiendra donc un ou plusieurs articles, et un article un ou plusieurs lots. Donc je lis mon fichier avec un FileReader et je le parcours avec un BufferedReader.
Le probleme c'est que les lignes concernant une meme commande ne sont pas les unes à la suite des autres, elles sont dispersées dans le fichier. Ma méthode :
Je lis ma ligne avec mon premier bufferedReader. Je memorise la ReferenceCommande de cette ligne dans une variable. Je vais ranger toutes les lignes concernant cette commande dans une hashmap. pour cela je parcour tout le fichier avec un deuxieme BufferedReader (et un deuxieme FileReader). Une fois la fin du fichier atteint j'ai donc recuperé toutes mes lignes pour cette commande. Je ferme donc les 2eme BufferedReader et FileReader, et je construit mes Lots et Articles, et ma Commande pour finir, que je range dans une HashMap qui contiendra donc toutes les commandes de ce fichier. Puis mon premier BufferedReader passe a la ligne suivante, je regarde si la referenceCommande de cette ligne n'et pas une commande deja traitée (j'ai mémorisé dans un ArrayList toutes les refCommandes déjà traité) et si ce n'est donc pas le cas, je recommence le traitement.
Probleme, avec 54 000 lignes, cette methode prendrai plus de 24h... en effet arrivé environ à la 22 000 ligne, le programme ne traite environ qu'une ligne toutes les 2 secondes. Plus le programme avance dans les lignes traitées, plus il ralenti.
A chaque commande toutes mes variables sont "vidées" excepté le HashMap qui contient toutes les commandes. Je ne sais pas tres bien comment fonctionne les BufferedReader et les FileReader, donc je ne sais pas si ce sont eux (les premiers, ceux qui restent ouverts) qui ralentissent mon application, ou bien uniquement le HashMap qui contient toutes mes commandes.
Bref je cherche un moyen d'optimiser le temps d'execution, si quelqu'un a une idée?? Merci d'avoir lu jusqu'au bout

[PP(Team)]

Tout d'abord, ne t'attends ps à avoir quelquechose qui prenne 2mn à l'exécution, car tes données sont trop "lourdes".

D'après ce que j'ai compris, tu recherche une commande, avec son id, tu recherches toutes les lignes concernant cette commande, et tu stocks temporairement tout ca dans une hashmap, et une fois toutes les données parcourues, tu mets ta hashmap temporaire dans une hashmap principale.

Est-ce bien cela ?

[adiGuba]

Salut,

Bref je cherche un moyen d'optimiser le temps d'execution, si quelqu'un a une idée?? Merci d'avoir lu jusqu'au bout

En même temps sans la moindre ligne de code cela risque d'être difficile...


Mais concernant on algo, je ne comprend pas ce qui t'empêche de faire une seule lecture :

1. Tu lis une ligne et tu récupères son "ReferenceCommande".
2. Tu utilises une Map qui contiendra toutes les "ReferenceCommande". Si elle n'est pas présente tu la crées et tu l'ajoutes, sinon tu la récupère.
3. Tu crées le Lot/Article correspondant à cette ligne
4. Tu passes à la ligne suivante et tu recommence

a++

[kahya]

Je n'ai pas bien compri ton 2), mais pour le reste, je ne construit pas un article a chaque ligne. En fait il me faut recuperer
1) dans le fichier, toutes les lignes qui concerne la commande en cours, je les range dans la Map maCommande (et ça pour toutes les commandes)
2) dans cette map maCommande, je recupere toutes les lignes de mon article en cours, je les range dans la Map monArticle (et ça pour chaque article)
3) une fois que j'ai isolé toutes les ligne de l'Aarticle en cours de la Commande en cours, je construit donc un lot, avec chacune de ces lignes. Une fois que j'ai construit mes lots avec toutes les lignes de ma Map article, je peux donc construire mon Article, qui contiendra ces lots dans un tableau. Et une fois que j'ai constuit tout mes articles (avec leurs lots) Je peux constuire ma commande qui contient tout ses articles (qui contiennent tout leurs lots).
Voila exactement comment ça se passe. Pour le code je veux bien mais je ne sais pas trop quel morceau mettre, ou alors je le met tout mais c'est long.

[adiGuba]

Le problème c'est que cela a l'air assez complexe et que sans code ni exemple des données traitées cela va être impossible de t'aider...


a++

[kahya]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
72
73
74
75
public void lireFichier(String fichier) 
	{
		ArrayList dejaTraite = new ArrayList();
		String CommandeActuelle = "";
		ArrayList CommandeEnCourLIST = new ArrayList();
 
		separateur = OrdreChamp.getSeparateur(ImportInterface.PathFichierOrdreChampClient, new ArrayList());
		ordre = OrdreChamp.remplirOrdre(ImportInterface.PathFichierOrdreChampCommandeClient, new ArrayList(), new ArrayList());
		try 
		{
			monLecteurFichier = new FileReader(fichier);
			tampon = new BufferedReader(monLecteurFichier);
			int cptLigne = 0;
			while (true) 
			{
				BufferedReader tampon2 = null;
				FileReader monLecteurFichier2 = new FileReader(fichier);
				String ligne = tampon.readLine();
				if (ligne == null)
					break;
				HashMap nouvelleLigneMAP = decouperLigne(ligne);
//				Si on ne l'a pas encore traité
				if (!dejaTraite.contains(nouvelleLigneMAP.get("H").toString()))
				{
					if (nouvelleLigneMAP.get("H").toString().compareToIgnoreCase("") != 0)
					{
						CommandeActuelle = nouvelleLigneMAP.get("H").toString();
						dejaTraite.add(nouvelleLigneMAP.get("H").toString());
						CommandeEnCourLIST = new ArrayList();
					}
					else
					{
						itéCommande ++;
						CommandeActuelle = "gene" + String.valueOf(itéCommande);
						dejaTraite.add("gene" + String.valueOf(itéCommande));
						CommandeEnCourLIST = new ArrayList();
						CommandeEnCourLIST.add(nouvelleLigneMAP);
					}
 
					cptCommande = 0;
					tampon2 = new BufferedReader(monLecteurFichier2);
					while (true) 
					{
						HashMap maLigne2Map = new HashMap();
						String ligne2 = tampon2.readLine();
						if (ligne2 == null)
							break;
 
						maLigne2Map = decouperLigne(ligne2);
						if (maLigne2Map.get("H").toString().compareToIgnoreCase(CommandeActuelle)== 0)
						{
							CommandeEnCourLIST.add(maLigne2Map);
							cptCommande ++;
						}
						cptLigne++;
					}
					tampon2.close();
					monLecteurFichier2.close();
					// On a notre AL avec toutes les lignes pour cette commande.
					maCommandeEnCourLIST = new ArrayList(CommandeEnCourLIST);
					while (maCommandeEnCourLIST.size()>0)
					{
						monArticleEnCourLIST = isolerArticle ();
						tempMonArticleEnCourLIST = new ArrayList(monArticleEnCourLIST);
						while (tempMonArticleEnCourLIST.size()>0)
						{
							construireLot ();
							indiceLot ++;	
						}
						construireArticle();
					}
					construireCommande(CommandeEnCourLIST);
				}
			}
		}

nouvelleLigneMAP c'est une Map qui contient toute ma ligne "découpée". Par exemple nouvelleLigneMAP.get("H") renvoi ce qu'il y a dans la colone H sur ma ligne en cours, si on ouvre le fichier contenant les données avec Excell. Et c'est donc la méthode decouperLigne qui se charge de créer cette Map nouvelleLigneMap.
Voila c'est le code qui fait le traitement, dites moi si vous voulez aussi le code des methodes construireLot construireCommande etc...

[PP(Team)]

Je pense que le raisonnement est bon, rien à optimiser la dessus.

Le problème est qu'un élément du code pourrait tout ralentir (par exemple, un oubli de destruction qui te prendrais de la mémoire).

C'est le problème de gérer des bases de données relativement importantes et de faire des traitements lourds dessus.

Car là, si tu as 1000 commandes différentes, tu vas parcourir au moins 1000 fois ta table, ça prend déjà pas mal de temps.


Donc je pense qu'il serait plus simple que tu parcours une seule fois ta liste, tu la ranges dans une List, une fois cette liste remplie, tu la trie (méthode Collections.sort(l)).

Comme ca, une fois que tu auras trouvée une nouvelle commande, tu fais list.remove(nb).

Ce qui fait que plus ca va venir, et plus les traitements seront rapides.


NB : ce n'est qu'une idée

[kahya]

C'est exactement ce que j'avais fait au debut, probleme il n'arrive pas jusqu'au 54 000 lignes, vers la 44 000eme il me fait un plantage avec un message d'erreur du genre que java n'a plus de memoire je ne sais plus exactement ce qu'il dit. c'est pour ça que je me suis tourné vers le traitement ligne par ligne. Et en effet, pour chaque ligne, mon 2eme lecteur lit tout le fichier, donc je vais lire 54 000 * 54 000 lignes....

Le fait que le traitement soit long ça c'est sur je n'y peux rien, mais ça me semble bizare que ça ralentisse. C'est ce que je voudrai resoudre en fait, et à part la HashMap qui contient toutes les commandes (que j'ecris dans un fichier tout à la fin du traitement) et les premiers BufferedReader et FileReader, je détruit tout, enfin il me semble. Par contre j'ai beaucoup de variable en global, alors est-ce que quand je donne par exemple i=1 et ensuite i=2, il se contente de remplacer la valeur, ou il garderai en mémoire toutes les affectations que j'ai faite? Dans ce cas ça pourrai alourdir le traitement.. Je debute en Java donc je ne sais pas trop vers où chercher :/

[PP(Team)]

C'est exactement ce que j'avais fait au debut, probleme il n'arrive pas jusqu'au 54 000 lignes, vers la 44 000eme il me fait un plantage avec un message d'erreur du genre que java n'a plus de memoire je ne sais plus exactement ce qu'il dit. c'est pour ça que je me suis tourné vers le traitement ligne par ligne. Et en effet, pour chaque ligne, mon 2eme lecteur lit tout le fichier, donc je vais lire 54 000 * 54 000 lignes....

Le fait que le traitement soit long ça c'est sur je n'y peux rien, mais ça me semble bizare que ça ralentisse. C'est ce que je voudrai resoudre en fait, et à part la HashMap qui contient toutes les commandes (que j'ecris dans un fichier tout à la fin du traitement) et les premiers BufferedReader et FileReader, je détruit tout, enfin il me semble. Par contre j'ai beaucoup de variable en global, alors est-ce que quand je donne par exemple i=1 et ensuite i=2, il se contente de remplacer la valeur, ou il garderai en mémoire toutes les affectations que j'ai faite? Dans ce cas ça pourrai alourdir le traitement.. Je debute en Java donc je ne sais pas trop vers où chercher :/

Ton problème (plantage au bout de 44000 lignes) pour moi, ca vient du fait que tu ne détruisais pas les hashmap que tu avais utilisé, car, à part si tu as très peu de rams, je ne vois pas comment un traitement de ce type peut remplir tes rams.

Donc si tu as encore ce code, essaye de voir si tu n'as pas oublié des destructions ou autre, car pour moi, cette solution est la meilleure des 2 (la première idée est souvent la meilleure).

[kahya]

J'avais essayé juste en remplissant une Hashmap avec mes lignes et ça ne marchai pas J'ai 512 de ram

[adiGuba]

C'est exactement ce que j'avais fait au debut, probleme il n'arrive pas jusqu'au 54 000 lignes, vers la 44 000eme il me fait un plantage avec un message d'erreur du genre que java n'a plus de memoire je ne sais plus exactement ce qu'il dit. c'est pour ça que je me suis tourné vers le traitement ligne par ligne. Et en effet, pour chaque ligne, mon 2eme lecteur lit tout le fichier, donc je vais lire 54 000 * 54 000 lignes....

Si la mémoire est insuffisante, que tu lises le fichier en une fois ou en plusieurs fois cela reviendrait au même...

Ensuite je vois plusieurs problèmes dans ton code :

1. Tu laisses plein de fichier ouvert :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
	FileReader monLecteurFichier2 = new FileReader(fichier);
	String ligne = tampon.readLine();
	if (ligne == null)
		break;
	HashMap nouvelleLigneMAP = decouperLigne(ligne);
// Si on ne l'a pas encore traité
	if (!dejaTraite.contains(nouvelleLigneMAP.get("H").toString()))
	{
		// Plein de traitement...
 
		monLecteurFichier2.close();
	}

Si on ne rentre pas dans le if le fichier n'est pas fermé
Il faut TOUJOURS utiliser des finally pour fermer les flux.




2. Dans ce code tu utilises plusieurs variables qui ne sont pas déclaré (itéCommande, cptCommande, maCommandeEnCourLIST, tempMonArticleEnCourLIST, monArticleEnCourLIST...). Donc je suppose que ce doit être des attributs d'instance... Or d'après ton code ce serait plus des variables locales !!!


3. Tu utilises beaucoups de List/Map dans tous les sens (et je n'ai pas trop compris pourquoi)



Pour moi le traitement devrait être beaucoup plus simple :
Tu lis le fichier ligne à ligne en associant chaque ligne à la bonne commande selon son identifiant (par exemple en stockant le tout dans une Map).

Et à la fin de la lecture tu crées tes objets...


Bref quelque chose du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
	public void lireFichier(String fichier) {
 
		try {
			Map mesCommandes = new HashMap(); // Liste des commandes par leurs identifiant
 
			// On ouvre le fichier en lecture :
			BufferedReader tampon = new BufferedReader(new FileReader(fichier));
			try {
				String ligne;
				// On lit ligne par ligne
				while((ligne=tampon.readLine()) != null) {
					Map nouvelleLigneMAP = decouperLigne(ligne);
 
					if ( /* la commande est présente dans la map */ ) {
						// on utilise cette commande
					} else {
						// on crée cette commande et on l'ajoute dans la liste
					}
 
					// On ajoute la ligne dans la commande
				}
 
			} finally {
				tampon.close();
			}
 
			// Une fois que le fichier est complètement lu
			// On parcours la map pour générer les articles
		} catch (IOException e) {
			e.printStackTrace(); // Traitement
		}
	}

a++

[kahya]

En effet ça me parait une bien meilleure idée! Je met ça en place et je vous tiens au courant ^^ merci beaucoup!

[kahya]

Ah oui mais la du coup on en revient au même : je ne peux pas charger tout le fichier dans une hashmap :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap space

Voila l'erreur, et voila mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
	FileReader monLecteurFichier = null;
		BufferedReader tampon = null;
		ArrayList CommandeEnCourLIST = new ArrayList();
 
		try 
		{
			HashMap mesCommandesMAP = new HashMap();
			HashMap nouvelleLigneMAP;
			monLecteurFichier = new FileReader(fichier);
			tampon = new BufferedReader(monLecteurFichier);
 
			while (true) 
			{
				String ligne = tampon.readLine();
				if (ligne == null)
					break;
				nouvelleLigneMAP = new HashMap(decouperLigne(ligne));
				if (mesCommandesMAP.containsKey(nouvelleLigneMAP.get("H").toString()))
				{
					ArrayList maCommande  = (ArrayList)mesCommandesMAP.get(nouvelleLigneMAP.get("H").toString());
					maCommande.add(nouvelleLigneMAP);
				}
				else
				{
					ArrayList maCommande = new ArrayList();
					maCommande.add(nouvelleLigneMAP);
					mesCommandesMAP.put(nouvelleLigneMAP.get("H").toString(), maCommande);
				}
			}
 
		}
		catch (IOException exception) 
		{
			exception.printStackTrace();
		} 
		finally 
		{	        
			try 
			{
				tampon.close();
				monLecteurFichier.close();
			} 
			catch(IOException exception1) 
			{
				exception1.printStackTrace();
			}
		}

[adiGuba]

Ah oui mais la du coup on en revient au même : je ne peux pas charger tout le fichier dans une hashmap :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap space

Quel est la taille de ton fichier ? Et de la mémoire allouer à la JVM ?
As-tu exécuter l'autre version jusqu'à la fin ? Car le problème peut venir de la quantité de donnée et non pas du code... car si je ne me trompe pas dans l'autre code tu stockes aussi toutes les données !

a++

[kahya]

C'est vrai que je stocke tout, dans la Map finale et non pas dans l'initiale, et du coup ça devrait planter tout pareil. Non je ne l'ai pas testé jusqu'à la fin car comme je l'ai di je pense qu'il prends plus de 24h donc pas encore eu le temps =)
mon fichier fait 5.71Mo et la mémoire allouée a la JVM je ne sais pas où il faut regarder :/

[PP(Team)]

Mais déjà, comme l'a dit "adiGuba" et comme je l'avais suggéré, regarde bien à fermer tous tes fichiers, etc... dans ton code, et là, peut-être que ca fonctionnera.

[kahya]

Je le teste en ce moment sur une autre classe qui fonctionne exactement pareil mais qui pointe sur un fichier de 8000 lignes seulement. Ca marche mais ça ralentis toujours. Dans le gestionnaire de tâches windows je n'ai plu que 45Mo de Ram dispo sur mes 512 Mo

[adiGuba]

A quoi ressemble tes lignes dans le fichier ? Et à quoi ressemble decouperLigne() ?

a++

[kahya]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
try 
		{
 
			HashMap nouvelleLigneMAP;
			monLecteurFichier = new FileReader(fichier);
			tampon = new BufferedReader(monLecteurFichier);
 
			while (true) 
			{
 
				String ligne = tampon.readLine();
				if (ligne == null)
					break;
				nouvelleLigneMAP = new HashMap(decouperLigne(ligne));
				if (mesCommandesMAP.containsKey(nouvelleLigneMAP.get("H").toString()))
				{
					ArrayList maCommande  = (ArrayList)mesCommandesMAP.get(nouvelleLigneMAP.get("H").toString());
					maCommande.add(nouvelleLigneMAP);
				}
				else
				{
					ArrayList maCommande = new ArrayList();
					maCommande.add(nouvelleLigneMAP);
					mesCommandesMAP.put(nouvelleLigneMAP.get("H").toString(), maCommande);
					cptNouvCommande++;
					System.out.println("NOUVELLE COMMANDE " + cptNouvCommande); //sto debug
				}
				cpt++;
				System.out.println(cpt); //sto debug
			}
		}
		catch (IOException exception) 
		{
			exception.printStackTrace();
		} 
		finally 
		{	        
			try 
			{
				tampon.close();
				monLecteurFichier.close();
 
			} 
			catch(IOException exception1) 
			{
				exception1.printStackTrace();
			}
		}
 
 
			for (Object o :mesCommandesMAP.keySet())
			{
				CommandeEnCourLIST = new ArrayList(maCommandeEnCourLIST);
				maCommandeEnCourLIST = new ArrayList((ArrayList)mesCommandesMAP.get((String)o));
				while (maCommandeEnCourLIST.size()>0)
				{
					monArticleEnCourLIST = new ArrayList(isolerArticle ());
					tempMonArticleEnCourLIST = new ArrayList(monArticleEnCourLIST);
					while (tempMonArticleEnCourLIST.size()>0)
					{
						construireLot ();
						indiceLot ++;	
					}
					construireArticle();
				}
				construireCommande(CommandeEnCourLIST);
				System.out.println("COMMANDE"); //sto debug
			}

Voila mon code, la premiere partie (dans le try catch) prends quelqque secondes, par contre c'est la partie dans le For qui est longue. A chaque fois que je passe dans le for, je crée des nouvelles instances de mes HashMap (par exemple CommandeEnCourLIST = new ArrayList(maCommandeEnCourLIST); ) est-ce que le probleme ne vient pas que du coup j'ai pleins d'instances de chaque HashMap et ArrayList en mémoire? Et si oui coment les détruire?

Voila une ligne de mon fichier (enfin la structure) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Date	NumeroPiece	NumeroClient	RefArticle	Qte	PUNet	MontantHT	NumPieceBC	NumPieceBL	DateBC	DateBL	DateLiv	RefFournisseur  NumLot	PU	PUTTC	MontantTTC	DatePeremption	ResteALivrer

Et decouperLigne() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public HashMap decouperLigne(String ligne)
	{
		int indiceOrdre = 0;
		if (ligne != null)
		{
			int indiceLigne = 0;
			String verifChaine = ligne;
			boolean continuer = true;
 
			indiceOrdre = 0;
			HashMap maLigneMAP = new HashMap();
			while (continuer)
			{
				verifChaine = verifChaine.substring(indiceLigne, verifChaine.length());
				if (verifChaine.contains(separateur))
				{	
					indiceLigne = verifChaine.indexOf(separateur)+1;
 
					if (verifChaine.substring(0, indiceLigne -1) != null){
						maLigneMAP.put(ordreLIST.get(indiceOrdre).toString(), verifChaine.substring(0, indiceLigne -1));
					}
					else
					{
						maLigneMAP.put(ordreLIST.get(indiceOrdre).toString(), "");
					}
				}
				else
				{
					if (verifChaine != null){
					maLigneMAP.put(ordreLIST.get(indiceOrdre).toString(), verifChaine);
					}
					else
					{
						maLigneMAP.put(ordreLIST.get(indiceOrdre).toString(), "");
					}
					continuer = false;
				}
				indiceOrdre ++;
			}
			return maLigneMAP;
		}
		else
		{
			return null;
		}
	}

où ordre est un ArrayList qui contient le "nom" des champs récupérés (en fait le nom des colonnes où on recupere la valeur : A, B, C...)

[adiGuba]

Voila mon code, la premiere partie (dans le try catch) prends quelqque secondes, par contre c'est la partie dans le For qui est longue.

Donc ce n'est pas la lecture des données mais bien tes traitements qui posent problème...
La lecture en plusieurs fois est bel et bien inutile !!!

A chaque fois que je passe dans le for, je crée des nouvelles instances de mes HashMap (par exemple CommandeEnCourLIST = new ArrayList(maCommandeEnCourLIST); ) est-ce que le probleme ne vient pas que du coup j'ai pleins d'instances de chaque HashMap et ArrayList en mémoire? Et si oui coment les détruire?

1. En limitant leurs durées de vie, ce que je t'ai dit dans mon premier post, c'est à dire en évitant de les déclarer en tant qu'attribut d'instance de la classe, mais uniquement dans le bloc où elles sont utilisées ( où sont déclaré CommandeEnCourLIST, maCommandeEnCourLIST, ...)

2. En évitant de faire des copies des List/Map si cela n'est pas vraiment utile. La mémoire sera bien libéré dans tous les cas mais cela évite de faire des allocations/libérations de mémoire inutile...



De plus je trouve que tu abuses vraiment des structures de données ! Ne serait-il pas mieux d'utiliser un objet métier comme valeur de retour de la méthode decouperLigne() ???

a++