11 min pour 60k lignes en java

**delta07** · 19/02/2010, 11h35

Bonjour,
voila dans un code que je viens d ecrire je lis un fichier en entree (xml) de plus de 63000 lignes et j utilise ensuite certaine expressions reguliere pour remplacer certaine sequence.

Pour lire le fichier j utilise un bufferReader qui lis ligne par ligne.

Probleme : 11 minutes pour lire ces 60 000 lignes !!!

Est ce normal ? y a t il un moyen plus rapide ?

Merci

**Deaf** · 19/02/2010, 11h41

Bonjour.

Cela me paraît bien trop long. Il nous faudrait en savoir plus pour t'aider davantage.

Ceci dit, est-ce indispensable de lire un XML avec un Reader? Un parser ne pourrait-il pas faire l'affaire?

Quel genre de remplacement fais-tu?

**delta07** · 19/02/2010, 11h43

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
 
 
public class Main {
 
 
	public static void main(String[] args) {
 
 
		String texteFlux = readFile();
 
		 texteFlux = regexp1(texteFlux);
		 texteFlux = regexp2(texteFlux);
		 texteFlux = regexp3(texteFlux);
		 texteFlux = regexp4(texteFlux);
		 texteFlux = regexp5(texteFlux);
 
		 //System.out.println();
	}
 
	static String readFile (){
		FileReader input;
		String texte = "";
 
 
		System.out.println("Entrer le path de votre fichier");
 
		Scanner sc = new Scanner(System.in);
	    String path = sc.nextLine();
 
		try {
			input = new FileReader(path);
			BufferedReader br = new BufferedReader(input);
 
			String line=null;
			try {
				while((line=br.readLine())!=null){
				texte+=line;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
 
		} catch (FileNotFoundException e) {			
			e.printStackTrace();
		}
 
		return texte;
	}
 
 
	static  String regexp1 (String input) {
 
			String resultat = input;	
 
			String first = "<Table(\\s[^<]+)*><TR(\\s[^<]+)*>(<TD(\\s[^<]+)*>[^<]*<\\\\TD>)?<TD(\\s[^<]+)*>IBM\\\\Chartered\\\\GLOBALFOUNDRIES\\\\Infineon\\\\Samsung\\\\ST <\\\\TD>.*?<\\\\Table>";
 
 
			Pattern regexpInput = Pattern.compile(first);
			Matcher matcherInput = regexpInput.matcher(input);
			Vector<String> outPutString = new Vector<String>();
 
			while (matcherInput.find()) {
				String tmpString = matcherInput.replaceAll("");
				if (!outPutString.contains(tmpString)) {
					outPutString.add(tmpString);
 
				}
				resultat = tmpString;
				//System.out.println("Number of substitution performed to remove footpages:"+i+"\n");
			}
			System.out.println(resultat);
			return resultat;
		}
 
	static  String regexp2 (String input) {
 
		String resultat = input;	
 
		String first = "<\\\\Table><Table(\\s[^<]+)*>(<[^>]*>)*?(?<!<Caption>)";
		Pattern regexpInput = Pattern.compile(first);
		Matcher matcherInput = regexpInput.matcher(input);
		Vector<String> outPutString = new Vector<String>();
		int i=0;
		while (matcherInput.find()) {
			String tmpString = matcherInput.replaceAll("");
			if (!outPutString.contains(tmpString)) {
				outPutString.add(tmpString);
				i++;
			}
			resultat = tmpString;
			System.out.println("Number of substitution performed to remove footpages:"+i+"\n");
		}
		return resultat;
	}
 
	static  String regexp3 (String input) {
 
		String resultat = input;	
 
		String first = "(Table\\s[0-9-]+[\\.\\:\\s]+[^<]+)<\\\\P>[^<]*<Table(\\s[^<]+)*>";
		Pattern regexpInput = Pattern.compile(first);
		Matcher matcherInput = regexpInput.matcher(input);
		Vector<String> outPutString = new Vector<String>();
		int i=0;
		while (matcherInput.find()) {
			String g1 = matcherInput.group(1);
			String tmpString = matcherInput.replaceAll("<\\\\P>\\n<Table><Caption><P>"+g1+"<\\P><\\\\Caption>");
			if (!outPutString.contains(tmpString)) {
				outPutString.add(tmpString);
				i++;
			}
			resultat = tmpString;
			System.out.println("Number of substitution performed to remove footpages:"+i+"\n");
		}
		return resultat;
	}
 
	static  String regexp4 (String input) {
 
	String resultat = input;	
 
	String first = "(Rule Set\\s[0-9-]+[\\:]+[^<]+)<\\\\P>[^<]*(<Figure>(.*?)<\\\\Figure>)*<Table(\\s[^<]+)*>";
	Pattern regexpInput = Pattern.compile(first);
	Matcher matcherInput = regexpInput.matcher(input);
	Vector<String> outPutString = new Vector<String>();
	int i=0;
	while (matcherInput.find()) {
		String g1 = matcherInput.group(1);
		String tmpString = matcherInput.replaceAll("<\\\\P>\\n<Table><Caption><P>"+g1+"<\\\\P><\\\\Caption>");
		if (!outPutString.contains(tmpString)) {
			outPutString.add(tmpString);
			i++;
		}
		resultat = tmpString;
		System.out.println("Number of substitution performed to remove footpages:"+i+"\n");
	}
	return resultat;
}
 
	static  String regexp5 (String input) {
 
	String resultat = input;	
 
	String first = "(?<!<Caption>)<P>(Table\\s[0-9-]+[\\.\\:\\s]+[^<]+)<\\\\P>";
	Pattern regexpInput = Pattern.compile(first);
	Matcher matcherInput = regexpInput.matcher(input);
	Vector<String> outPutString = new Vector<String>();
	int i=0;
	while (matcherInput.find()) {
		String g1 = matcherInput.group(1);
		String tmpString = matcherInput.replaceAll("\\n<Caption><P>"+g1+"<\\\\P><\\\\Caption>");
		if (!outPutString.contains(tmpString)) {
			outPutString.add(tmpString);
			i++;
		}
		resultat = tmpString;
		System.out.println("Number of substitution performed to remove footpages:"+i+"\n");
	}
	return resultat;
}
 
 
}

voila mon code

Ce que tu dit m interesse, quelle difference entre un parser et le bufferreader ?

**Deaf** · 19/02/2010, 11h58

Au premier coup d'oeil, ce qui te plombe le plus, c'est certainement la concaténation de String:

Code :

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

1
2
3
4
5
String texte = "";
...
while((line=br.readLine())!=null){
    texte+=line;
}

Rien qu'en utilisant un StringBuilder, tu devrait déjà y gagner:

Code :

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

1
2
3
4
5
StringBuilder builder = new StringBuilder();
...
while((line=br.readLine())!=null){
    builder.append(line);
}

Après, je pense qu'il y a d'autres points que l'on peut améliorer.

**adiGuba** · 19/02/2010, 12h12

Salut,

Déjà ta lecture du fichier est catastrophique : tu concatènes chaque ligne dans une String avec +, ce qui crée plusieurs objets temporaires à chaque boucle.

Il faut utiliser un StringBuilder/StringBuffer pour cela !

Ensuite la lecture par ligne est inutile puisque tu veux récupérer tout le fichier en mémoire. Autant faire directement une lecture par bloc dans ce cas là...

Il manque également le try/finally pour la fermeture des ressources, et une gestion propre des exceptions

Enfin je n'ai pas trop regardé tes méthodes regexp() en détail car je ne sais pas ce qu'elle doivent faire, mais il y a des points qui me choque un peu :

Ton Vector est complètement inutile...
Tu n'as pas à utiliser à replaceAll() dans la boucle sur find().
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
1
2
while (matcherInput.find()) {
		String tmpString = matcherInput.replaceAll("");
```
Soit on utilise find() pour rechercher les données, soit on utilises directement replaceAll() pour remplacer toutes les données. Mais en aucun cas il ne faut les utiliser ensemble !
D'ailleurs je ne comprend pas l'intérêt de la boucle puisque tu n'y traites jamais les données spécifiques. Tu refais plusieurs fois le même traitement. En fait du peu que j'en voit un String.replaceAll() ferait la même chose en beaucoup plus rapide...

a++

**delta07** · 19/02/2010, 13h48

Merci de ces precisions

Je tiens juste a dire pour ma defense que je suis en premiere annee de bts info, et que je "touche"au java depuis peu de temps.

Je m empresse de changer tout ca en stringBuilder deja et je reviendrai certainement vers vous.

Merci beaucoup

**delta07** · 19/02/2010, 13h59

ok ca y est je suis perdu ^^

je ne connaissai pas du tout StringBuilder et maintenant que j ai change j ai plein de truc en rouge.

Sachant qu au depart j ai ca :

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
	String resultat = texteFlux;	
 
		String first = "<\\\\Table><Table(\\s[^<]+)*>(<[^>]*>)*?(?<!<Caption>)";
		Pattern regexpInput = Pattern.compile(first);
		Matcher matcherInput = regexpInput.matcher(texteFlux);
		Vector<String> outPutString = new Vector<String>();
		int i=0;
		while (matcherInput.find()) {
			String tmpString = matcherInput.replaceAll("");
			if (!outPutString.contains(tmpString)) {
				outPutString.add(tmpString);
				i++;
			}
			resultat = tmpString;
			System.out.println("Number of substitution performed to remove footpages:"+i+"\n");
		}
		return resultat;

Comment dois je le modifier en StringBuilder, et comment me debarasser du Vector ?

11 min pour 60k lignes en java

avec Java

Vue hybride

Discussions similaires

Partager

Partager