Problème dans mon code

Version imprimable

Bonjour tout le monde, cela fait a peu pres 1 semaine que j'apprend le java, et je suis actuellement entrain de codé un logiciel qui devrait me permettre de tronquer des chaines de caracteres a un endroit précis.
Explications :
J'ai un fichier texte qui est constitué d'exactement 310 caracteres par ligne.
On attend de mon logiciel qu'il coupe ces 310 caracteres afin que je puisse l'insérer dans une base de donnée ensuite.
exemple :
Mon fichier texte de 310 caractere :

Code:

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

Ce que je voudrais que mon logiciel fasse :

Code:

zzz;zz;zzzz;zzzzzzzzzzz;zz;zzzzzzzzzzzzzzzzzzzzzz;zzzzzzz;zzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzz;zzzzzzzzzzzz;zzzzzz;zzzz

Comme il n'y a aucun séparateur dans ce fichier texte, je n'ai pas trouver d'autre moyen que de devoir insérer des ";" en guise de séparateur. (je ne sais pas si il y a un moyen plus facile, perso c'est le seul que j'ai trouvé)

Mon logiciel fonctionne très bien pour la premiere ligne de mon fichier, mais des qu'il passe a la 2e ligne, on dirait qu'il compte a partir de 3, puis 5, puis 7 ...

Voici mon code :

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
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
public class lire {
 
  private static int n;
 
public static void main(String[] args) throws IOException {
 
ArrayList al1= new ArrayList();      // cette liste contient tout les emplacements exacte où il faut mettre un ";"
al1.add(3);   // Apres le 3e carac 
al1.add(3);   //puis apres 3 carac
al1.add(1);	  //puis 1 ...
al1.add(6);
al1.add(4);
al1.add(2);
al1.add(9);
 
al1.add(2);
al1.add(4);
al1.add(8);
al1.add(30);
al1.add(65);
al1.add(1);
al1.add(47);
al1.add(8);
al1.add(8);
al1.add(8);
al1.add(8);
al1.add(8);
al1.add(85);   //ce qui nous fait 310 caracteres
 
FileInputStream fis = null;
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("test2.txt", true));
 
try {
 
    fis = new FileInputStream(new File("test.txt"));
 
    byte[] buf = new byte[8];       // Je n'ai trouvé que cette méthode pour lire caractere par caractere
 
    int n = 0;
 
    int compteurCaractere = 0;     // a chaque caractere ecrit, ce compteur fait son travail
    int compteurCaractere2 = 0;    // ce compteur compte jusqu'au 310e caractere, pour que je sache quand j'ai fini la ligne
    int compteurAl1 = 0;              //compteur qui me permet de naviguer dans mon arraylist afin de placer les ";"
 
    while ((n = fis.read(buf)) >= 0) {
    for (byte bit : buf) {
 
    	   bufferedWriter.write((char)bit);// j'ecris ce qu'a lu la boucle au format char
    	   System.out.print( (char) bit);
 
          compteurCaractere += 1;
          compteurCaractere2 +=1;
 
          	if ( compteurCaractere ==(int) al1.get(compteurAl1)){ //si le compteur = 1er element de mon arraylist, je réinitialise compteur,
          														  //et j'ajoute 1 a compteurAl1 pour passer au 2e element de mon array .. etc
          			bufferedWriter.write(";");	
          			System.out.print(";");
          		//fos.write(10);
 
          			compteurCaractere = 0;
          			compteurAl1 += 1;
          		 /*if (compteurAl1 == 20){
          			 
          			 compteurCaractere =0;
          			 compteurAl1 = 0;
          		 }*/
 
          	}
          if ((compteurCaractere2 == 310) && (compteurAl1 == 20) ){ //si j'arrive au 310e caractere ou que je suis au bout de mon Arraylist
          			//compteurCaractere = 0; 
          			compteurAl1 = 0;                                //je reviens au debut de mon Arraylist
          			compteurCaractere2=0;                           //je réinitialise mon compteur de caractere
          			};
 
 
       }
       //je réinitialise le buffer à vide
       //au cas où les derniers byte lus ne soient pas un multiple de 8
       //Ca me permet d'avoir un buffer vierge à chaque lecture et ne pas avoir de doublon en fin de fichier
       buf = new byte[8];
 
   }
    System.out.println("Copie terminée !");
    bufferedWriter.close();
 } catch (FileNotFoundException e) {
    // Cette exception est levée si l'objet FileInputStream ne trouve
    // aucun fichier
    e.printStackTrace();
 } catch (IOException e) {
    // Celle-ci se produit lors d'une erreur d'écriture ou de lecture
    e.printStackTrace();
 } finally {
    // je ferme les flux de données dans un bloc finally pour s'assurer
    // que ces instructions seront exécutées dans tous les cas même si
    // une exception est levée !
    try {
       if (fis != null)
          fis.close();
    } catch (IOException e) {
       e.printStackTrace();
    }
  }
  }}

Je trouve que mon code est correct, pourtant voici ce qu'il renvoie :

Code:

1
2
3
4
zzz;zzz;z;zzzzzz;zzzz;zz;zzzzzzzzz;zz;zzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;z;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
z;zzz;z;zzzzzz;zzzz;zz;zzzzzzzzz;zz;zzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;z;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zz
;
zz;z;zzzzzz;zzzz;zz;zzzzzzzzz;zz;zzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;z;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzz;z

Ce que je voudrais :

Code:

1
2
3
4
 
zzz;zzz;z;zzzzzz;zzzz;zz;zzzzzzzzz;zz;zzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;z;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
zzz;zzz;z;zzzzzz;zzzz;zz;zzzzzzzzz;zz;zzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;z;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
zzz;zzz;z;zzzzzz;zzzz;zz;zzzzzzzzz;zz;zzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;z;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;

comme vous pouvez le voir, la premiere ligne est bien coué tout les 3/3/1/6/4/2... caracteres
Mais la 2e ligne est coupé apres 1/3/1/6/4/2..
et la 3e tout les 2/1/6/4/2..
Comme si il décalait de +2 caracteres a chaque ligne. j'ai pensé a un caractere invisible comme le \n
Mais je ne trouve pas de solution :(
N'hésiter pas a me dire si il y a des méthodes beaucoup plus simple pour insérer un caractere, ou si il y a une méthode plus simple de remplir son ArrayList, et je suis surtout perdu au niveau de la lecture/ecriture, il y a tellement d'outil ..
Merci d'avance pour votre aide

22/01/2015, 16h26
zaza576

Hello,

ne serait-ce pas ce fameux "caractère de fin / saut de ligne" (\n) qui serait pris en considération lors du découpage de tes lignes ?
Cela paraît donc normal qu'il y ait ce décalage de 2 caractères !
22/01/2015, 17h57
thelvin

Hello,

Le problème de ton code, c'est qu'il est bien trop compliqué.

Approche plus simple :
- lire le fichier ligne par ligne (et non pas octet par octet)
- pour chaque ligne, calculer ce qu'il faut écrire à la place de cette ligne
- écrire le résultat dans le fichier de sortie.

Pour lire un fichier ligne par ligne, la FAQ Java répond à ce genre de questions, pas de risque de se noyer dans les possibilités.

Salut essaye ca.
Je te laisse le soin de faire la fonction pour ecrire dans le fichier texte

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
public class Lire {
 
  private static int n;
 
public static void main(String[] args) throws IOException {
 
ArrayList al1= new ArrayList();      // cette liste contient tout les emplacements exacte où il faut mettre un ";"
al1.add(3);   // Apres le 3e carac 
al1.add(3);   //puis apres 3 carac
al1.add(1);	  //puis 1 ...
al1.add(6);
al1.add(4);
al1.add(2);
al1.add(9);
al1.add(2);
al1.add(4);
al1.add(8);
al1.add(30);
al1.add(65);
al1.add(1);
al1.add(47);
al1.add(8);
al1.add(8);
al1.add(8);
al1.add(8);
al1.add(8);
al1.add(85);   //ce qui nous fait 310 caracteres
 
Scanner scanner = new Scanner(new File("test.txt"));
// On boucle sur chaque champ detecté
while (scanner.hasNextLine()) {
    String line = scanner.nextLine();
    String tutu = "";
    int comp2 = 0;
    int comp = 0;
    for (int i = 0 ;i<al1.size();i++){
 
        int t = (int) al1.get(i);
         comp2 += t;
        tutu += line.substring(comp, comp2) + ";";
        comp = comp2;
 
    }
 
 
    System.out.println(tutu);
//ecrire dans test2.txt
}
 
scanner.close();
 
  }}

22/01/2015, 19h18
joel.drigo
Salut,

Entre parenthèses, pourquoi utiliser une liste pour stocker les tailles de découpage ?

C'est plus clair et lisible comme ça :

Code:

int[] tailles = { 3, 3, 1, 6};

Sans parler du parcours, également plus simple et lisible :
Code:

1 2 3 4 5 6 7 for(int taille : tailles ) { comp2 += taille; ... }
(je ne parle pas des multiples concaténations de String qu'on devrait gérer avec un StringBuilder, le propos n'étant peut-être pas à ce niveau, mais par habitude, dans ce genre de boucle, y penser, voire carrément écrire directement dans le flux de sortie lorsqu'il est question d'obtenir un nouveau fichier).
22/01/2015, 19h34
p4atch

Merci tout le monde.
Comme je l'ai déjà dit, ça fait 1 semaine seulement que j’apprends le java, donc je suis encore un peu perdu.
Je n'ai pas mon code chez moi, je vais donc testez ce que vous m'avez conseillé demain matin au boulot, et je vous tiendrais au courant.
Encore merci

Effectivement comme ca c'est plus propre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args) throws IOException {
 int[] tailles = { 3, 3, 1, 6,4,2,9,2,4,8,30,65,1,47,8,8,8,8,8,85};
Scanner scanner = new Scanner(new File("test.txt"));
while (scanner.hasNextLine()) {
    String line = scanner.nextLine();
    String tutu = "";
    int comp2 = 0;
    int comp = 0;
   for(int taille : tailles ) {
       comp2 += taille;
        tutu += line.substring(comp, comp2) + ";";
        comp = comp2;
   }
 
    System.out.println(tutu);
}
 
scanner.close();
 
  }

par contre je ne vois pas comment faire pour

Citation:

voire carrément écrire directement dans le flux de sortie lorsqu'il est question d'obtenir un nouveau fichier

Citation:

Envoyé par hugoclo

Citation:

Envoyé par joel.drigo

voire carrément écrire directement dans le flux de sortie lorsqu'il est question d'obtenir un nouveau fichier).

par contre je ne vois pas comment faire pour
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("output.txt"))) { for (String line : Files.readAllLines(Paths.get("test.txt"))) { int comp2 = 0; int comp = 0; for (int taille : tailles) { comp2 += taille; writer.write(line.substring(comp, comp2)); writer.write(';'); comp = comp2; } } }

J'ai essayer vos conseils ce matin, mon code fonctionne tres bien, je vous en remercie, mais mon code est loin d'etre terminé(ce serait trop simple), et j'aimerais vous demandez quelques conseils pour la suite :

Le probleme est que tronquer toutes les lignes de la meme facon ne suffit pas
J'ai donc 6 modeles de "tronquage" pour mes lignes, et ils n'ont pas d'ordres précis.
Code:

1 2 3 4 5 6 int[] decoupage1 = {3,3,1,6,4,2,9,2,4,8,30,65,1,47,8,8,8,8,8,85}; //correspond a la 1ere ligne int[] decoupage2 = {3,3,1,6,4,2,9,1,30,3,8,8,30,1,8,8,8,8,8,8,8,8,8,8,8,1,8,8,8,8,8,8,30,1,1,1,1,4,1,9,4,1,4,1,1,5}; // correspond a la 2e ligne int[] decoupage5 = {3,3,1,6,4,2,9,3,3,4,3,10,2,10,35,32,32,32,32,32,1,1,10,10,20,4,4,2}; //correspond a la 3e ligne int[] decoupage7 = {3,3,1,6,4,2,9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,10,8,8,8,8,8,8,8,8,8,8,8,8,9,15}; //puis chaque ligne varie entre les 3 int[] decoupage6 = {3,3,1,6,4,2,9,35,35,32,32,32,32,32,1,1,50}; //decoupages suivants int[] decoupage8 = {3,3,1,6,4,2,9,30,10,10,10,10,10,10,10,10,1,9,9,9,9,9,9,9,9,9,9,9,2,70};
C'est a dire qu'avant de tronquer chaque ligne, mon programme doit reconnaitre le type d'information contenue dans la ligne, pour ensuite la tronquer selon le bon decoupage.
J'ai pensé qu'il faut utilisé des regex pour résoudre ce probleme, Mais je n'ai encore jamais essayer d'en utilisé, et j'aimerais savoir si je me dirige sur le bon chemin où si il existe d'autres manieres.

23/01/2015, 13h39
thelvin

Ben d'habitude c'est plutôt avec des regex qu'on détermine si une ligne "ressemble à ceci ou cela," oui.
Mais en pratique, ça dépend concrètement ce qu'il y a à vérifier.
23/01/2015, 16h09
hugoclo

Salut
De quoi dépend le tronquage: un terme de la ligne, une entête, une fin de ligne etc

Edit : je n'avais pas vu vos reponses. Ce que je dois vérifier, si si il est écrit A1/P1/N1/C1/" " au 18 et 19e caractere.
j'ai donc fait des regex qui vérifie les 19 premiers caracteres

Hello, je viens de finir ma journée, et je vais solicité une derniere fois votre aide ^^'
J'ai mis en place mes regex, je compare ma ligne a la regex, si ce n'est bon, je la compare a la 2e regex .. etc
Le programme fonctionne avec la premiere ligne, puis il fonctionne avec la 2e ligne, mais apres il coupe les 40 000 lignes suivantes de la meme facon que la ligne 2, et je ne comprends pas pourquoi.

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
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
109
110
111
112
113
114
115
116
117
118
119
120
121
 
int[] decoupage1 = {3,3,1,6,4,2,9,2,4,8,30,65,1,47,8,8,8,8,8,85};
int[] decoupage2 = {3,3,1,6,4,2,9,1,30,3,8,8,30,1,8,8,8,8,8,8,8,8,8,8,8,1,8,8,8,8,8,8,30,1,1,1,1,4,1,9,4,1,4,1,1,5}; 
int[] decoupage5 = {3,3,1,6,4,2,9,3,3,4,3,10,2,10,35,32,32,32,32,32,1,1,10,10,20,4,4,2};
int[] decoupage7 = {3,3,1,6,4,2,9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,10,8,8,8,8,8,8,8,8,8,8,8,8,9,15};
int[] decoupage6 = {3,3,1,6,4,2,9,35,35,32,32,32,32,32,1,1,50};
int[] decoupage8 = {3,3,1,6,4,2,9,30,10,10,10,10,10,10,10,10,1,9,9,9,9,9,9,9,9,9,9,9,2,70};
 
int[] decoupage3 = {3,3,1,6,4,2,9,1,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,3,38};
int[] decoupage4 = {3,3,1,6,4,2,9,1,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,31};
 
Pattern regex1 = Pattern.compile("[0-9]{6}[^0-9]{7}L105[^0-9]{2}");
Pattern regex2 = Pattern.compile("[0-9]{6}[^0-9]{7}L105A1");
Pattern regex3 = Pattern.compile("[0-9]{6}.[0-9]{6}L105C1");
Pattern regex4 = Pattern.compile("[0-9]{6}.[0-9]{6}L105N1");
Pattern regex5 = Pattern.compile("[0-9]{6}.[0-9]{6}L105P1");
//regex6 ...
//regex7 ...
//regex8 ...
 
Scanner scanner = new Scanner(new File("test.txt"));
		bw = new BufferedWriter(new FileWriter("test2.txt", false));
 
		while (scanner.hasNextLine()) {
 
		    String line = scanner.nextLine();
		    String tutu = "";
		    int comp2 = 0;
		    int comp = 0;
		    System.out.print("|------|  ");
		    Matcher m = regex1.matcher(line);
		    // ---------------------- Test Regex 1 -------------------------- 
		    if (m.find()){
			   for(int taille : decoupage1) {
				   	comp2 += taille;
			        tutu += line.substring(comp, comp2) + ";";
			        comp = comp2;
			        if(comp2 == 310){
			        	tutu+="\n";
			        	break;
			        }}}
 
		    // ---------------------- Test Regex 2 --------------------------
		    else{
		    	m = regex2.matcher(line);
		    	if(m.find()){
		    		for(int taille : decoupage2 ) {
		    			comp2 += taille;
				        tutu += line.substring(comp, comp2) + ";";
				        comp = comp2;
				        if(comp2 == 310){
				        	tutu+="\n";
				        	break;
				        }}}
 
		    // ---------------------- Test Regex 3 --------------------------
		    	else{
		    		m = regex3.matcher(line);
			    	if(m.find()){
			    		for(int taille : decoupage2 ) {
			    			comp2 += taille;
					        tutu += line.substring(comp, comp2) + ";";
					        comp = comp2;
					        if(comp2 == 310){
					        	tutu+="\n";
					        	break;
					        }}}
			 // ---------------------- Test Regex 4 --------------------------
			    	else{
			    		m = regex4.matcher(line);
				    	if(m.find()){
				    		for(int taille : decoupage2 ) {
				    			comp2 += taille;
						        tutu += line.substring(comp, comp2) + ";";
						        comp = comp2;
						        if(comp2 == 310){
						        	tutu+="\n";
						        	break;
						        }}}
			// ---------------------- Test Regex 5 --------------------------
				    	else{   
				    		m = regex5.matcher(line);
					    	if(m.find()){
					    		for(int taille : decoupage2 ) {
					    			comp2 += taille;
							        tutu += line.substring(comp, comp2) + ";";
							        comp = comp2;
							        if(comp2 == 310){
							        	tutu+="\n";
							        	break;
							        }}}
			// ---------------------- Test Regex 6 --------------------------
					    	/*else{   
					    		m = regex6.matcher(line);
						    	if(m.find()){
						    		for(int taille : decoupage2 ) {
						    			comp2 += taille;
								        tutu += line.substring(comp, comp2) + ";";
								        comp = comp2;
								        if(comp2 == 310){
								        	tutu+="\t";
								        }}}
 
 
				    	}*/
				    	}
			    	}
		    	}
		    }
 
 
		    bw.write(tutu);
		    System.out.print(tutu);
 
 
		}
 
		 bw.close();
		scanner.close();
 
		  }}

j'ai pensé a un probleme avec les "break" dans mes boucles, j'ai lu qu'il etait deconseillé d'utiliser ca.
Merci d'avance :)

23/01/2015, 16h17
hugoclo
Salut si tu veux employer des if pourquoi ne pas
Code:

1 2 3 4 if(line.contains("L105A1")){ decoupage 2} else if(line.contains("L105C1")){ decoupage3 etc}
ou alors avec les regex essaye de ne pas te servir pas des else. Il ne sont pas placé au bon endroit. Regarde ton code quoi qu'il arrive si le premier n'est pas bon il fais le 2iéme.
23/01/2015, 17h32
joel.drigo
Je ne suis pas contre le principe d'utiliser des regexp, même si, lorsque la position et la taille de ce qu'on veut tester sont fixes (18 et 2), un substring est suffisant (avec une Map pour choisir le bon tableau), mais faire des if/else en série, là non : si tu as 300 regexp, tu vas faire 300 else/if ? en plus pour y dupliquer la même boucle, à la différence d'un simple paramètre (le tableau) ? Et si tu t'aperçois ensuite qu'il faut modifier légèrement l'algorithme de découpage, tu vas modifier 300 boucles ?
1. les méthodes, ça existe, pour éviter de dupliquer le code (surtout que les paramètres permettent de faire des variations) ;
2. les boucles, ça existent aussi : si tu mets tes regexp dans une liste, et que tu parcours ta liste, tu auras un code de 5 lignes au lieux de n fois 5 lignes... (plus le code est concis et répétitif, plus on évite les erreurs, et plus facile, il est, de les trouver le cas échéant).
En plus, tu utilises la concaténation pour fabriquer une String, en bouclant sur 40000 lignes fois n entiers ? Tu n'as pas de contrainte de temps ?

Si ton programme découpe toutes les lignes selon le découpage 2, c'est parce que dans toutes tes boucles, sauf la première, tu utilises le tableau decoupage2 : il va falloir que tu remplaces les tableaux dans les boucles après la 2ème par les bons tableau : là, tu en que 4 à modifier. Heureusement, que tu n'en as pas 300 ! Enfin, moi, je dis ça, c'est pas moi qui vais me taper les modifications... mais c'est quand même un bon cas pour confirmer mon argument ci-avant.
26/01/2015, 09h31
p4atch

Salut.
Effectivement, vu de ce point de vue, je vais de suite mieux organiser mon code !!
Et désolé pour l'erreur stupide avec le decoupage2, apres correction j'arrive a decouper les 40 000 lignes de mon fichier correctement, et elle m'aura servi d'exemple pour ton explication x)

Et pour ce qui est de la contrainte du temps, je suis assez surpris, meme avec les boucles a repetition, il ne m'as fallu que 10 secondes pour parcourir les 40000 lignes.

EDIT : Je tenais a vous remercier encore une fois, grace a votre aide mon logiciel et presque finit, il reste encore 2/3 bricole a faire, mais je pense que je pourrais me debrouiller tout seul. Vous m'avez economisé des heures voir des jours de reflexion.