Découpage d'un fichier texte en java.

**Albulle** · 20/02/2017, 13h54

Bonjour,

Je cherche à découper un fichier extension en plusieurs fichiers selon la valeur d'une ligne, je me suis totalement inspiré d'un poste équivalent, mais je n'arrive pas à générer autant de fichier qu'attendu.

Ci-joint le 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
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
public class Eclatement {
	private static File destDir;
	private static BufferedReader reader;
	private static File file;
 
	public static File[] splitFile(String filePath, String toDir)
			throws IOException {
		handleToDir(toDir);
		File[] splittedFiles;
		List<File> files = new ArrayList<File>();
		reader = new BufferedReader(new FileReader(filePath));
		String fileName = new File(filePath).getName();
		StringBuffer fileContent = new StringBuffer();
		String line;
		File currentFile = Eclatement.createSplittedFile(fileName, files
				.size());
		while ((line = reader.readLine()) != null) {
			fileContent.append(line+"\n");
			if (line.equals("P*")) {
				Eclatement.writeFile(currentFile, fileContent.toString());
				//System.out.println(currentFile);
				files.add(currentFile);
				fileContent = new StringBuffer();
			currentFile = Eclatement.createSplittedFile(fileName, files
						.size());
			}
		}
		Eclatement.writeFile(currentFile, fileContent.toString());
 
		files.add(currentFile);
 
		splittedFiles = new File[files.size()];
		int c=0;
		for (int i = 0; i < files.size(); i++) {
			setFile(files.get(i));
			splittedFiles[c] = files.get(c);
			c++;
		}
		return splittedFiles;
	}
 
	/**
         * @return the file
         */
	public static File getFile() {
		return file;
	}
 
	/**
         * @param file the file to set
         */
	public static void setFile(File file) {
		Eclatement.file = file;
	}
 
	private static void handleToDir(String toDir) {
		destDir = new File(toDir);
		if (destDir.exists())
			destDir.delete();
		destDir.mkdir();
	}
 
	private static File createSplittedFile(String fileName, int index) {
 
   File file=new File(destDir, fileName); // pas terrible, cette variable destDir statique !!!
   String name = file.getName(); 
   int pos = name.lastIndexOf("."); // détection de l'extension
   if( pos<0 ) {
      // pas d'extension
      name += "." + index;
   }
   else {
      name = name.substring(0,pos)+"."+index+name.substring(pos);
   }
   return new File(file.getParentFile(), name);
	}
 
	private static void writeFile(File destFile, String content)
			throws IOException {
		BufferedWriter writer = new BufferedWriter(new FileWriter(destFile));
		writer.write(content);
		//System.out.println(content);
		writer.flush();
		writer.close();
		writer = null;
	}
 
	public static void main(String[] args) {
		try {
			// 1048576 = 1Mo
			System.out.println(Eclatement.splitFile("C:/Users/user/Desktop/FICHIER.HPR",
					"C:/Users/user/Desktop/cible").length
					+ " files generated");
 
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Ci-joint un extrait du fichier à découper :

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
P|1|000000067145|6285548838|1226730|nom~prénon|NOM|20000904|||adresse||0tel|npr~Docteur Nom Prénom~L
FAC|1|1226730|6285548838|201610112130|450000047~npr~Docteur 	Nom Prénom|adeli~qui~qui
ACT|1|B|65|1|1|B65||451016232~00015~DC LABO|5201|HRE
ACT|2|B|5|1|1|B5||451016232~00015~DC LABO|9106|HR
ACT|3|B|16|1|1|B16||451016232~00015~DC LABO|9005|HR
P|2|000000067145|6285548838|1226730|nom~prénon|NOM|20000904|||adresse||0tel|npr~Docteur Nom Prénom~L
FAC|1|1226730|6285548838|201610112130|450000047~npr~Docteur 	Nom Prénom|adeli~qui~qui
ACT|1|B|65|1|1|B65||451016232~00015~DC LABO|5201|HRE
P|3|000000067145|6285548838|1226730|nom~prénon|NOM|20000904|||adresse||0tel|npr~Docteur Nom Prénom~L
FAC|1|1226730|6285548838|201610112130|450000047~npr~Docteur 	Nom Prénom|adeli~qui~qui
ACT|1|B|65|1|1|B65||451016232~00015~DC LABO|5201|HRE
ACT|2|B|5|1|1|B5||451016232~00015~DC LABO|9106|HR
ACT|3|B|16|1|1|B16||451016232~00015~DC LABO|9005|HR
ACT|4|B|16|1|1|B16||451016232~00015~DC LABO|1205|HR
ACT|5|B|16|1|1|B16||451016232~00015~DC LABO|3000|HR
ACT|6|B|16|1|1|B16||451016232~00015~DC LABO|4000|HR
....

L'idée est de sortir un fichier pour chaque P|X| avec une seule qui réunit les lignes en dessous des P actuels.

Je vous remercie d'avance,

**Cafeinoman** · 20/02/2017, 14h39

Une version corrigée et commentée de splitFile :

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
public static File[] splitFile(String filePath, String toDir)
    throws IOException {
    handleToDir(toDir);
    List<File> files = new ArrayList<File>();
    reader = new BufferedReader(new FileReader(filePath));
    String fileName = new File(filePath).getName();
    StringBuffer fileContent = new StringBuffer(); // un StringBuilder serait mieux
 
    reader.lines().forEach(l -> fileContent.append(l).append(System.lineSeparator())); // on lit toutes les lignes et on les concatène, avec la méthode #lines, apparue avec java 8
    /*Si on doit rester avec java 7 ou inférieur :
    String line;
    while ((line = reader.readLine()) != null) {
      fileContent.append(line);
    }*/
    String[] parts = fileContent.toString().split("P\\|"); // on découpe à chaque fois qu'on trouve "P|"
    for(int i = 1; i < parts.length;i++){ //on ignore la string à l'index 0, qui est vide (la partie situé avant le premier "P|")
      String part = "P|"+parts[i]; //on rajoute le "P|" enlevé lors du split
      File currentFile = Eclatement.createSplittedFile(fileName,i-1); //on utilise l'index -1 (pour partir de zéro) pour créer le nombre exact de fichiers
      Eclatement.writeFile(currentFile,part);
      files.add(currentFile);
    }
    return files.toArray(new File[files.size()]); // on utilise toArray, tout simplement...
  }

Petite remarque a passage, utilise plutôt System.lineSeparator() pour les saut de ligne, c'est portable entre les différent OS. Pareil pour le dossier de l'utilisateur, utilise plutôt System.getProperty("user.home"), qui retournera le dossier de l'utilisateur quel que soit le système.
Autre chose, le fait de tout avoir en static n'est pas forcément génial...

N'hésite pas si tu as des question.

**Albulle** · 20/02/2017, 15h20

Bonjour,

Je te remercie, je prends note de tes conseils, je vais optimiser le programme d'après ce que tu m'as dit. Après pour le dossier user, le script va tourner sur un serveur avec des répertoires définis donc je pense que je peux laisser en dur, la je teste seulement sur mon poste.

Merci encore,

**joel.drigo** · 20/02/2017, 15h42

On peut faire ça sans split, concaténation, etc (et accèssoirement, en consommant moins de mémoire).

Un truc comme ça (il faudrait un peu améliorer, je n'aime pas trop le "continue", mais si c'est pour du one shot, ça fera l'affaire) :

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
 
String input = "c:/toto/input.txt";
String output = "c:/toto/output_%d.txt";
 
int index=1;
try(BufferedReader reader = Files.newBufferedReader(Paths.get(input),StandardCharsets.UTF_8)) { // adapter le charset...
 
    String line=null;
    do {
        if ( line!=null && line.startsWith("P|") ) { 
            try(BufferedWriter writer = Files.newBufferedWriter(Paths.get(String.format(output,index++)),StandardCharsets.UTF_8)) {
                do {
		    writer.write(line);
		    line = reader.readLine();
	        } while( line != null && !line.startsWith("P|") );
	        continue;
	    }
	}
	line = reader.readLine();
    } while(line!=null);
 
}

[EDIT]Voilà, encore plus simple :

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
int index=1;
		try(BufferedReader reader = Files.newBufferedReader(Paths.get(input),StandardCharsets.UTF_8)) {
 
			for(String line = reader.readLine(); line!=null; ) {
				if ( line.startsWith("P|") ) {
					try(BufferedWriter writer = Files.newBufferedWriter(Paths.get(String.format(output,index++)),StandardCharsets.UTF_8)) {
						writer.write(line); 
						for(line = reader.readLine(); line!=null; ) {
							if ( line.startsWith("P|") ) break;
							writer.write(line);
						}
					}
				}
			}
 
		}

**Cafeinoman** · 20/02/2017, 17h56

Envoyé par joel.drigo

On peut faire ça sans split, concaténation, etc (et accèssoirement, en consommant moins de mémoire).

Si l'extrait des données est représentatif... si on a des "P|" qui ne sont pas en début de ligne, on ne peut pas se passer du split je crois? (c'est pour ce cas que je n'ai pas utilisé le startWith...)

**joel.drigo** · 20/02/2017, 18h33

Certes. J'ai présupposé que le format était respecté. Tout comme mon prog ne reprend pas les lignes qui seraient devant le premier P| (j'ai supposé qu'on avait bien des séquences, P suivi de non P, alternées). C'est toujours la même problématique : est-ce une moulinette à utiliser une fois pour convertir un fichier inadapté (dont le format est connu et immuable, et éventuellement corrigeable à la main au cas pour élimininer les cas particuliers), ou pour traiter en masse une conversion qui va être appliquée à des milliers d'entrées potentiellement mal formées. Dans ton programme, par exemple, s'il y a un libellé (d'une colonne qui n'est pas la dernière) qui se termine par P, tu vas couper une ligne en deux (parce que P| sera détecté à tord).

En tout cas, on peut modifier mon prog pour traiter le cas du P en plein milieu, ça introduirait 2 indexof et subtring (pas de split, pas de concaténation).

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
int index=1;
		try(BufferedReader reader = Files.newBufferedReader(Paths.get(input),StandardCharsets.UTF_8)) {
 
			for(String line = reader.readLine(); line!=null; ) {
				int i=line.indexOf("P|");
				if (i>0) {
					line = line.substring(i);
				}
				if ( i>=0 ) {
					try(BufferedWriter writer = Files.newBufferedWriter(Paths.get(String.format(output,index++)),StandardCharsets.UTF_8)) {
						writer.write(line); 
						while( (line=reader.readLine())!=null ) {
							int pos=line.indexOf("P|");
							if (pos>0) {
								writer.write(line.substring(0,pos));
								break;
							}
							else if ( pos==0 ) {
								break;
							}
							else {
								writer.write(line);
							}
						}
					}
				}
			}
 
		}

Un peu plus complexe s'il faut traiter le cas du P en fin de libellé (il faudrait un Pattern/Matcher à la place de indexof/substring ).

**Albulle** · 20/02/2017, 18h58

Bonjour,

Pour répondre à votre question. Il ne s'agit pas d'un programme qui va tourner un boucle, ceci étant ce n'est qu'une toute petite partie du programme.

L'objectif est de transformer des messages qui arrivent sous un format inadapté vers un format adapté et normé. Ici, c'est la première étape, il s'agit d'un voir un message par P (patient) et non pas un message pour X P après le formalisme même du premier message est tel que cité en exemple au départ.

Après, je vous remercie pour vos apports parce que le java n'est pas langage que je maîtrise mon langage de base (initialement, je fais du dwh et développement BDD sous oracle) alors je prends note de ce qu'on me dit.

Merci encore.

**joel.drigo** · 20/02/2017, 19h18

Envoyé par Albulle

L'objectif est de transformer des messages qui arrivent sous un format inadapté vers un format adapté et normé. Ici, c'est la première étape, il s'agit d'un voir un message par P (patient) et non pas un message pour X P après le formalisme même du premier message est tel que cité en exemple au départ.

Il y a 2 choses importantes dans ces phrases :

qui arrive : c'est à dire qui arrive d'où ? Si le fichier est produit par une application, en théorie, cette application doit être suffisamment bien faite pour que le fichier soit sans erreur (en cas d'erreur d'ecriture, le fichier ne devrait pas être envoyé). Idem s'il y a transfert, le système de transfert s'assure que le transfert est fait sans erreur et complet. Si le fichier est entrée par un utilisateur au clavier dans un éditeur de texte, on peut être sûr à 100% qu'il y aura des erreurs, donc il faut les traiter.
des messages : donc traitement non unique, et probablement automatisé (ou du moins semi automatisé) : ce n'est donc pas une moulinette pour laquelle on peut se permettre de bidouiller un peu le fichier pour éviter de gérer des cas complexes. Le "des" impliquent forcement une question sur les quantités, le nombre et la fréquence : un fichier de 20 patients tous les mois, ou 70000 fichiers de 15000 patients toutes les 3 minutes ? Ceci pour déterminer si on peut faire fi de l'empreinte mémoire d'un importe, ou si c'est crucial pour éviter de faire planter l'application pour "out of memory"

**Albulle** · 20/02/2017, 23h14

Pour te répondre :

1 ) L'objectif du programme est de transformer un message d'un format dans autre. Pourquoi les éditeurs A et B ne peuvent pas communiquer directement, c'est parce que l'éditeur A envoie le message dans un standard qui vieillissant et alors que l'éditeur B n'accepte que le nouvelle norme. Après l'éditeur B est l'un de mes fournisseurs et ne développera sur un format qui va mourir. Pourquoi l'éditeur A ne développe pas sous le nouveau format, il l'a fait mais avec la version de logiciel utilisé par notre partenaire le laboratoire. La solution la plus simple est la plus efficace serait que le laboratoire migre de version de produit, ce qui n'est pas près d'arriver. Conclusion l'éditeur A et l'éditeur B ne peuvent rien faire. Après si je ne passe pas par un EAI c'est parce qu'au delà du formalisme différent (format HPRIM SANTE vers HPRIM XML), les champs et les valeurs envoyés comme attendus par l'un et l'autre sont différente.
Concrètement après la découpe du message initial, l'objet de ce poste, je l'édulcore et je l'enrichie les messages générés avec ce dont j'ai besoin, via des champs fixes et/ou calculés à partir de la base de donnée du logiciel de l'éditeur B.
Une fois cette consolidation faite, je passe du format HPRIM SANTE au format HPRIM XML.

2 ) Pour la volumétrie, un programme qui tourne seul à 04h du matin sur un serveur dédié chaque jour de la semaine pour traiter au maximum 300 patients ne devrait pas partir en vrille si chaque séquence est bien optimisé. C'est ce à quoi je m'emploie. Actuellement, je crée des classe unitairement, je teste et j'optimise autant que je peux par rapport à mon niveau de perception des subtilités et des possibilités du java. Après, juste ce découpage m'a prise 3 secondes pour fichier avec 1000 patients.

Petite question : "Autre chose, le fait de tout avoir en static n'est pas forcément génial...", j'avais compris que ce n'était pas génial. Alors avec maigres connaissance en java et cette définition :

"Par défaut, chaque instance de chaque classe occupe son propre espace mémoire. Deux objets instances d’une même classe occupent donc deux espaces mémoire qui ne se recouvrent pas. Lorsque que l’on déclare un membre statique ( static), il est au contraire placé dans un espace mémoire commun à tous les objets de la classe. Si un des objets modifie la valeur d’un champ statique (par exemple), tous les objets verront la valeur de ce champ modifiée"

Donc en ayant écrit static par tout j'alourdis le temps de traitement ?

Merci d'avance,

**joel.drigo** · 21/02/2017, 11h02

Envoyé par Albulle

Donc en ayant écrit static par tout j'alourdis le temps de traitement ?

Non, les performances ne sont pas directement impactées par l'emploi du static. C'est surtout l'architecture et la flexibilité qui sont touchées.

Découpage d'un fichier texte en java.

Java

Discussions similaires

Partager

Partager