Discussion :

[NeedToHelp]

Bonjour tt le monde;

pour un besoin d'indexation, je dois dans mon appli récupérer le contenu des fichiers ajoutés (formats supportés : Txt, Doc, rtf, Xls, PDF, JPG, GIF) et stocké par la suite tous les mots dans la base (mots-clés). pour faire, j'ai commencé par les fichiers text, mais le problème c'est que mon code est très lourds en éxécution (pour un fichier txt de 36.7 Mo il a pris 10 min)

Veuillez SVP me suggérer d'autres solutions afin de rendre mon code plus rapide et performant (Utilisation du Hashcode, lecture du fichier ligne par ligne...).

Voici 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
 
public static void main(String[] args)
	{
		System.out.println("Date de début : " + new Date());
 
		File fich = new File("C:\\FTP\\test_java.txt");
		int n;
		char c;
		String mot = "";
		Collection<String> col = new ArrayList<String>();
 
		try {
			FileReader fr = new FileReader(fich);
 
			while ((n = fr.read()) != -1)
			{
				c =(char) n;
				if (c != ' ' && c != '\r' && c != '\n' && c != '.' && c != ',' && c != ';' && c != ':'
					&& c != '!' && c != '?' && c != '/' && c != '\\' && c != '$' && c != '"'
					&& c != '&' && c != '(' && c != ')' && c != '[' && c != ']'
					&& c != '{' && c != '}' && c != '@' && c != '*' && c != '%')
					mot = mot + c;
				else
				{
					if (mot.length() > 3 && !col.contains(mot.toLowerCase()))
					{
						col.add(mot.toLowerCase());
					}
				mot = "";
				}
			}
			fr.close();
			col.clear();
			col = null;
			System.out.println("Date de fin : " + new Date());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

Merci infiniment pour votre collaboration habituelle.

[Pill_S]

Ouch!

la lecture byte par byte c'est vraiment pas le top. Mieux vaut lire par paquet de dison 10Ko (via un byte[]).

La lecture ligne par ligne avec un bufferedreader est également une option, et peut-être même mieux (tu récupère directement des string et pas des byte[])

[NeedToHelp]

Merci Pill_S pour votre réponse.

je me suis dit, si je récupère ligne par ligne, je dois ensuite retravailler la chaine pour récupérer les mots en éliminant les doublons, les espaces, les caractères de numértotation... je pense que ca sera plus lourd.
Bon, pour faire court et simple, mon besoin et de pouvoir récupérer du fichier tous les mots ayant une taille > à 3 et les stocké dans ma table indéxé, afin de pouvoir faire par la suite une recherche en Fulltext sur le document ajouté.

Merci.

[adiGuba]

Salut,

Même si tu n'a pas l'utilité d'une lecture ligne par ligne, tu peux utiliser un BufferedReader pour regrouper les lectures :

Code :

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

1
2
// FileReader fr = new FileReader(fich);
Reader fr = new BufferedReader(FileReader(fich));

Pour un fichier de 30Mo tu passes de 30 000 000 accès IO à moins de 4000 (lecture par buffer de 8192 par défaut).



Ensuite il faut éviter les multiples concaténations de String. Ce n'est pas fait pour cela et il est préférable d'utiliser des StringBuilder à la place :

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
//String mot = "";
StringBuilder builder = new StringBuilder();
 
 
...
 
 
	if (c != ' ' && c != '\r' && c != '\n' && c != '.' && c != ','
			&& c != ';' && c != ':' && c != '!' && c != '?'
			&& c != '/' && c != '\\' && c != '$' && c != '"'
			&& c != '&' && c != '(' && c != ')' && c != '['
			&& c != ']' && c != '{' && c != '}' && c != '@'
			&& c != '*' && c != '%')
		// mot = mot + c;
		builder.append(c);
	else {
		String mot = builder.toString().toLowerCase();
		if (mot.length() > 3 && !col.contains(mot)) {
			col.add(mot);
		}
		// mot = "";
		builder.setLength(0);
	}

Dans une boucle, la concaténation de String génère de multiples objets temporaires qui surcharge le GC. Il faut réserver cela à un usage ponctuelle. Pour la génération de chaine on doit utiliser les StringBuffer/StringBuilder...


Avec ces deux corrections tu devrais déjà bien boosté ton code...

Reste ensuite à utiliser un try/finally pour fermer le flux


a++

[tchize_]

pour indexer des document, pour information, il existe des librairies comme lucene. Avantages: support de plusieurs format texte déjà existant, recherche partielle, reconnaissance des mots similaire (pluriels, féminins, etc) avec indexation uniquement sous la forme basique du nom.

[NeedToHelp]

Tout d'abord je vous remercie infiniment (Pill_S, adiGuba et tchize_) pour toutes les suggéstions que vous m'avez proposé. vous prouvez chaque jour un haut niveau de compétence.

J'ai optimisé mon code en suivant vos conseils, et apparement ça à l'air mieux.
Mais j'ai trouvé en fin de compte que l'instruction d'ajout du mot à la collection --> ( col.add(mot); ) est celle qui alourdit le traitement, en désactivant cette dernière, je passe de 10 min à 4 sec !!! mais je n'ai pas d'autre moyen, car normalement cette collection est mappé avec avec une table (j'utilise Hibernate). j'espère que j'été clair.

Par rapport à Lucen, je pense que c'est une bonne idée, je vais me documenter un peu, et je vais vous faire part.
L'objectif c'est de trouver une sollution finale et mettre en résolu la discussion

Merci encore une fois pour votre collaboration et entraide.
A+