Discussion :

[Krokodile]

Bonjour,

Je débute en Java et je galère un peu (beaucoup).
Je vous explique mon problème, j'ai un fichier plat et je le lis grâce à Java.
Le but est de créer plusieurs fichiers de sortie (un fichier par commande).

Dans ce fichier, j'ai un numéro de commande (136670 et 136609):

136670 00000000000000000 ABC
136670 00000000000000000 ABD
136670 00000000000000000 ABE
136609 00000000000000000 ABC
136609 00000000000000000 ABD
136609 00000000000000000 ABD
136609 00000000000000000 ABE

J'ai donc crée une HashMap, ou je mets le numéro de commande 136670 puis 136609.
Ma HashMap actuel:
Clé: 136670
Valeurs: 136670 00000000000000000 ABC
136670 00000000000000000 ABD
136670 00000000000000000 ABE
Clé: 136609
Valeurs: 136609 00000000000000000 ABC
136609 00000000000000000 ABD
136609 00000000000000000 ABD
136609 00000000000000000 ABE

///

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
LinkedHashMap<String, StringBuilder> order = new LinkedHashMap<String, StringBuilder>();
			while((line = br.readLine()) != null){
				String lineId = line.substring(ORDER_START_POSITION, ORDER_END_POSITION);
				if(order.get(lineId) != null){
					StringBuilder stringBuilder = order.get(lineId);
					stringBuilder.append("\n"+(line));
					order.put(lineId, stringBuilder);
				}
				else{
					order.put(lineId, new StringBuilder(line));
					}
			}

J'ai mis l'essentiel du code. Je me sers du LinkedHashMap pour envoyer en sortie le fichier.

Mon code fonctionne mais je n'arrrive pas à faire deux choses me sont nécessaires:
- Si le nombre d'entrée de valeurs dans le LinkedHashMap est supérieurs à 2, je voudrai créer une nouvelle HashMap, puis 4 une nouvelle HashMap.
- Si le nombre d'entrée de valeurs dans le LinkedHashMap est supérieurs à 2, je veux incrémenter un chiffre de 800, si égal à 4 à 801 ainsi de suite.

Exemple avec mon fichier:

Clé: 136670
Valeurs: 136670 00000000000000000 ABC
136670 00000000000000000 ABD
Avec un code 800.

Clé: 136670
Valeurs: 136670 00000000000000000 ABE
Avec un code 801.

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

Clé: 136609
Valeurs: 136609 00000000000000000 ABC
136609 00000000000000000 ABD
Avec un code 800.

Clé: 136609
Valeurs: 136609 00000000000000000 ABE
136609 00000000000000000 ABF
Avec un code 801.

Clé: 136609
Valeurs: 136609 00000000000000000 ABE
Avec un code 802.

Le problème c'est que je n'arrive pas à découper mon HashMap en plusieurs HashMap.
J'ai pensé à passer par un LinkedHashMap, un TreeMap mais je n'arrive pas à découper un HashMap en plusieurs sous HashMap...

Avez-vous une idée pour réussir ce découpage ?

Merci d'avance.

[Gugelhupf]

Salut,

J'ai l'impression que tu te compliques la vie pour rien, pourquoi n'utilises-tu pas un typage plus clair comme Map<String, Commande> (le premier String représentant un identifiant unique et la Commande un tuple) ?
Commande serait un type contenant toutes les colonnes de ton fichier.
Aussi j'ai l'impression que tu lis un fichier de type CSV, tu as des librairies qui font tout le travail à ta place, comme Jackson CSV par exemple, tu peux à partir de ton fichier obtenir une liste de Commande.

A+

[Krokodile]

Salut,

J'ai l'impression que tu te compliques la vie pour rien, pourquoi n'utilises-tu pas un typage plus clair comme Map<String, Commande> (le premier String représentant un identifiant unique et la Commande un tuple) ?
Commande serait un type contenant toutes les colonnes de ton fichier.
Aussi j'ai l'impression que tu lis un fichier de type CSV, tu as des librairies qui font tout le travail à ta place, comme Jackson CSV par exemple, tu peux à partir de ton fichier obtenir une liste de Commande.

A+

Merci pour ta réponse Gugelhupf,
Je lis un fichier plat (sur Talend précisément donc je peux oublier les librairies) mais c'est du pur Java.

Là j'utilise un HashMap (ou LinkedHashMap) car chaque HashMap doit contenir toutes les lignes d'une seule commande, jusque là tout fonctionne.

Le problème c'est que si la commande contient 6 lignes, je voudrai 3 HashMap avec 2 lignes en quelque sorte (Je ne vois pas comment faire).

[Cafeinoman]

Le mieux serait, je pense, d'oublier la Map et de créer un objet ad hoc avec 4 champs : idCommande, valeur1 et valeur2 et code. Tu stockes tout tes objets dans une List, et tu filtres avec un stream quand tu dois les ressortir.

[Krokodile]

Merci pour vos réponses, je suis passé par une autre stratégie (grâce à Camel Simple).

Je souhaite découper le ligne une fois avec un numéro de commande unique deux par deux.

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
 private void ExtractOrderFromBAC02(ProducerTemplate producerTemplate, InputStream content, String endpoint, String fileName, HashMap<String, Object> headers){
    	    ArrayList<String> list = new ArrayList<String>();
    		BufferedReader br = new BufferedReader(new InputStreamReader(content));
    		String line;
    		long numSplits = 2; 				
    		int sourcesize=0;
    		int nof=0;
    		int number = 800;
    		try {				
    		    while((line = br.readLine()) != null){
    					sourcesize++;
    					list.add(line);
    			}
 
    		 System.out.println("Lines in the file: " + sourcesize);    
 
    		double numberFiles = (sourcesize/numSplits);  
    	    int numberFiles1=(int)numberFiles;  
    				if(sourcesize<=2)   {  
    				  nof=1;  
    				}  
    				else  {  
    			         nof=numberFiles1+1;  
    				}  
    	   System.out.println("No. of files to be generated :"+nof);
 
    	   for (int j=1;j<=nof;j++) {  
    				 number++;
    	             String  Filename = ""+ number;
    			   	 System.out.println(Filename);
 
    			StringBuilder builder = new StringBuilder();
    			for (String value : list) {
    			    builder.append("/n"+value);
    			}
 
    			 producerTemplate.sendBodyAndHeader(endpoint, builder.toString(), "CamelFileName",Filename);
    		}
 
    			 }  
 
    	     } catch (IOException e) {
    				e.printStackTrace();
    		 }
    			finally{
    				try {
    					if(br != null)br.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}

Je me sers du

Code :

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

 producerTemplate.sendBodyAndHeader(endpoint, builder.toString(), "CamelFileName",Filename);

endpoint ==> Ma destination
"CamelFileName",Filename ==> Pour le nom de mon fichier
builder.toString() ==> Le document à renvoyer.


Avec mon code, j'ai bien 3 fichiers mais à chaque fois avec l'intégralité du document et sans retour chariot.
Je souhaiterai donc découper mon ArrayList toutes les 2 occurrences mais je ne trouve pas comment je peux faire :s, j'ai tenté des boucles sur nombre de lignes, ça ne fonctionne pas...

Merci d'avance

[Cafeinoman]

Pour ce qui est des sauts de ligne, utilise System.lineSeparator() plutôt qu'une regex (qui devrait être \\n je pense).

Pour ce qui est du fait d'avoir toutes tes lignes dans le fichiers, c'est simplement parce que tu boucle sur toute ta liste...

Essais avec

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
private void ExtractOrderFromBAC02(ProducerTemplate producerTemplate, InputStream content, String endpoint, String fileName, HashMap<String, Object> headers){
    ArrayList<String> list = new ArrayList<String>();
    String line;
            long numSplits = 2;                 
            int sourcesize=0;
            int nof=0;
            int number = 800;
         
    try(BufferedReader br = new BufferedReader(new InputStreamReader(content))) { // try with resources qui economise de la place et facilite le catch
        while((line = br.readLine()) != null){
                                sourcesize++;
                                list.add(line);
                    }
System.out.println("Lines in the file: " + sourcesize);
for( int i = 0 ; i <= list.size() ; i+numberSplits) {
number++;
String  Filename = ""+ number;
System.out.println(Filename);
StringBuilder builder = new StringBuilder();
builder.append(list.get(i)).append(list.get(i+1);
producerTemplate.sendBodyAndHeader(endpoint, builder.toString(), "CamelFileName",Filename);
}
 
System.out.println("No. of files to be generated :"+nof);
    } catch (IOException e) {
                        e.printStackTrace();
             }
}

Le code me semble juste (même si sans IDE il peut y avoir des erreurs )

[Krokodile]

Pour ce qui est des sauts de ligne, utilise System.lineSeparator() plutôt qu'une regex (qui devrait être \\n je pense).

Pour ce qui est du fait d'avoir toutes tes lignes dans le fichiers, c'est simplement parce que tu boucle sur toute ta liste...

Essais avec

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
private void ExtractOrderFromBAC02(ProducerTemplate producerTemplate, InputStream content, String endpoint, String fileName, HashMap<String, Object> headers){
    ArrayList<String> list = new ArrayList<String>();
    String line;
            long numSplits = 2;                 
            int sourcesize=0;
            int nof=0;
            int number = 800;
         
    try(BufferedReader br = new BufferedReader(new InputStreamReader(content))) { // try with resources qui economise de la place et facilite le catch
        while((line = br.readLine()) != null){
                                sourcesize++;
                                list.add(line);
                    }
System.out.println("Lines in the file: " + sourcesize);
for( int i = 0 ; i <= list.size() ; i+numberSplits) {
number++;
String  Filename = ""+ number;
System.out.println(Filename);
StringBuilder builder = new StringBuilder();
builder.append(list.get(i)).append(list.get(i+1);
producerTemplate.sendBodyAndHeader(endpoint, builder.toString(), "CamelFileName",Filename);
}
 
System.out.println("No. of files to be generated :"+nof);
    } catch (IOException e) {
                        e.printStackTrace();
             }
}

Le code me semble juste (même si sans IDE il peut y avoir des erreurs )

Merci c'est vraiment génial de m'aider autant !
J'ai juste corrigé ça:

Code :

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

	for( int i = 0 ; i <= list.size() ;i+=numSplits) {

Mais il y a une erreur quand il arrive à la fin du fichier, par exemple avec 134 lignes.
J'ai tenté de mettre i < list.size(), ça marche avec 134 lignes mais pas 135 lignes.

Et j'ai un petit ajout à faire. Quand j'ai lancé mon code, mes 67 fichiers se sont générés mais je me suis rendu compte que je devrais peut-être splitter mon fichier par 10, 20, ou 50, enfin que je puisse augmenter la valeur numSplits (vraiment désolé de ne pas l'avoir vu avant ).
J'ai cherché sur internet mais je n'ai pas trouvé ....

Super le System.lineSeparator() !

En tout cas, un grand merci pour le temps que tu me consacres (Je débute en Java et je galère beaucoup)