Bonjour à tous,

Je dois écrire une classe java qui permet de créer une base de données de x clients à partir du résultat aléatoire des noms,prénoms,numéro de rue et nom de rue.
Le fichier résultant CLIENTS.DATA sera composé de d 'enregistrements ayant comme format :
NOM
PRENOM
ADRESSE

Si vous regardez mon programme , et que vous le compilez :
Erreur IO : NOMS.TXT (Le fichier spécifié est introuvable)

En fait il me manque dans mon programme des instructions permettant d 'aller pointer sur les fichiers concernés .

Avez vous une idée?

Merçi d 'avance

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
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
 
import java.io.*;
import java.util.*;
 
 
/** Cette classe permet la création d'une base aléatoire
 * de clients à partir de fichiers contenant des noms,
 * prénoms et adresse inventés        
 */
 
public class CreationClient {
 
/** Cette méthode lit dans un tableau chaque ligne
 * d'un fichier dont le nom est spécifié en argument 
 * @return Retourne le nombre de lignes lues
 */
 
public static int lit(String[]st,String fichier) throws IOException{
 
	int nbLignesLues =0;
 
	FileInputStream fs = new FileInputStream(fichier);
 
	/* Utilisation de InputStreamReader pour effectuer 
	 * la transformation en caractères 
	 * Utilisation de BufferedReader pour lire toutes 
	 * les entrées séparées par un caractère  de fin de ligne
	 * à l 'aide de la méthode readline 
	 */
 
	BufferedReader b = new BufferedReader(new InputStreamReader(fs));
 
	String ligne;
 
	while ((ligne = b.readLine()) != null){
		st[nbLignesLues] =ligne;
		nbLignesLues++;
	}
	return nbLignesLues;
 
}
 
public static void main (String[] args){
 
	int nbNoms,nbPrenoms,nbAdresses;
 
	String[] tsNoms = new String[5];
	String[] tsPrenoms = new String[5];
	String[] tsAdresses = new String[5];
 
 
 
	try{
 
		File f= new File ("c:\\*.TXT");
 
 
		// Lecture dans des tableaux 
 
		nbNoms = lit(tsNoms,"NOMS.TXT");
		nbPrenoms = lit(tsPrenoms,"PRENOMS.TXT");
		nbAdresses = lit(tsAdresses,"ADRESSES.TXT");
 
		// Création du fichier à accès aléatoire
 
		RandomAccessFile rf = new RandomAccessFile("CLIENTS.DAT","rw");
 
		for (int n=0;n<5;n++){
 
			String nom = tsNoms[(int)Math.random()*nbNoms];
			String prenom = tsPrenoms[(int)Math.random()*nbNoms];
			String adresse = tsAdresses[(int)Math.random()*nbNoms];
 
 
		// Le numero est aléatoire entre 1 et 301
 
			int numero = (int)(Math.random()*300)+1;
 
		/* L 'adresse est composée d'un nom de rue,d'un code	
		 * postal et d'une ville séparés par des ';'
		 */
 
			StringTokenizer stk = new StringTokenizer(adresse,";");
			String rue ="";int codepost=0;String ville="";
 
			if (stk.hasMoreTokens())
		        rue=stk.nextToken();
 
			if (stk.hasMoreTokens())
				codepost=Integer.parseInt(stk.nextToken());
 
			if (stk.hasMoreTokens())	
				ville=stk.nextToken();
 
 
			// On affiche à la console le résultat (pour test)
 
				System.out.println(nom+ "," +prenom+ "-" +numero+ "," +rue+ "-" +codepost+ " "+ville); 
 
 
			// On écrit ces données dans le rf le RandomAcessFile 
 
				ecritComplementAZero(rf,nom,20);
				ecritComplementAZero(rf,prenom,20);
				ecritComplementAZero(rf,numero+ "," +rue,40);
				rf.write(codepost);
				ecritComplementAZero(rf,ville,10);
		}
 
 
		    // Fermeture du fichier .C'est terminé 
 
		      		rf.close();
 
	}
 
	       catch(IOException e){
	    	   System.out.println("Erreur IO : " +e.getMessage());
	       }
 
}
 
 
		 /* Permet d 'écrire une chaine , en la tronquant à la limite 
			  * de la taille du champ , ou la complémentant à 0	
			  * laméthode void ecritEtComplementeAZero(
			*RandomAccessFile, String, int) prend en argument le fichier dans
			*lequel écrire la chaîne de caractères passée en second argument.
			*Le troisième argument est le nombre de caractères maximum. Il est impératif de
			*respecter la taille fixe de chaque enregistrement. Si la chaine est plus petite que la
			*taille de l'enregistrement, alors elle est complémentée par des octets à zéro. Si par
			*contre elle est plus grande, alors elle sera tronquée.
			*Le nombre d'octets écrits sur le fichier est le nombre de caractères multiplié par deux.
			*En effet, l'encodage utilisé est "UTF-16BE" (UTF 16 bits en Big Endian), c'est à dire
			*sur deux octets, l'octet de poids fort étant en fin. Il faudra utiliser le même codage à la
			*lecture.
				*/
 
 
			static void ecritComplementAZero(RandomAccessFile rf,String ch,int ta) throws IOException{
 
				byte[] tVide = new byte[512]; // Tableau vide pour complémenter les chaines de taille inferieure
 
				if (ch.length() >=ta)
					rf.write(ch.getBytes(),0,ta*2);
 
				else {
					 rf.write(ch.getBytes("UTF-16BE")); // Encodage UNICODE
					 rf.write(tVide,0,((ta - ch.length())*2));
 
				}
 
			}
 
 
}