Page Sources Java libres - participez ici [Sources] - Page 5

JackHack · 09/05/2008, 14h12

Auteur : JackHack
Titre : Applet se comportant comme Java Webstart

Bonjour voici une petite API qui permet depuis une Applet de lancer un jar éxécutable.
Comme Java webstart, elle copie en local vos jar et resources necessaires à votre application, puis lance votre application.
Mais en plus elle vous laisse la main libre sur la barre de progression de la copie.
Elle vous permet aussi de copiée des fichiers après le lancement.
Et elle évite de multiples boîte de dialogue de validation, une seule en fait est nécessaire, c'est la signature de l'Applet et c'est tout.

Bon j'ai tout mis dans le zip joins (documentation comprise

)

Jack Hack

Philcmoi · 24/05/2008, 10h26

il suffit de faire :

Code :

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

1
2
3
Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT+01:00"), Locale.FRANCE);
Date date1=calendar.getTime();
String dateString=DateFormat.getDateInstance().format(date1);

Voila j'espère que ca servira car c'est un sujet frequament aborde

Philcmoi · 24/05/2008, 23h40

Ce code utilise l'api java mail 1.3.

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
public void Confirmation(String email) throws Exception {
			String emailfrom = "Companier@Companie.fr";
			String emailto = email;
 
			// Récupére les propriétés du systéme
			Properties props = System.getProperties();
 
			// Spécification du serveur mail
			props.put("mail.smtp.host", "smtp.free.fr");
 
			// Récupère la session
			javax.mail.Session session = javax.mail.Session.getDefaultInstance(props, null);
 
			// Définition du message
			MimeMessage message = new MimeMessage(session);
			//Spécification de l'expéditeur
			try {
				message.setFrom(new InternetAddress(emailfrom));
			} catch (AddressException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (MessagingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//Spécification du destinataire
			try {
				message.addRecipient(Message.RecipientType.TO, new InternetAddress(emailto));
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				//throw exception;
			} 
			//Sujet du message
			try {
				message.setSubject("www.Companie.fr Utilisateurs");
			} catch (MessagingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//Texte du message on y introduit un lien hypertext appelant une servlet du cote serveur qui esr ConfirmationDemandeProjet
 
			String url = "http://www.Companie.fr/servlet/ConfirmationDemandeProjet?email="+email;
 
 
			String htmlText="<html><head><title>message.html</title>"+"<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">"
			+"<meta http-equiv=\"description\" content=\"this is my page\"><meta http-equiv=\"content-type\" content=\"text/html; charset=ISO-8859-1\">"+
		    "<!--<link rel=\"stylesheet\" type=\"text/css\" href=\"./styles.css\">--></head><body><p>&nbsp;Merci de vous etes inscrit sur VisioClear.fr</p>"+
		  "<p>Votre adrese email est :"+email+"</p>"+
		  "<p>veuilliez cliquer sur ce lien pour confirmer votre demande de devis :<A HREF=\""+url +"\">ici</A></body></html>";

lorsque le client sérieux qui a bien donné son adresse email cliquera sur ici, la vérification sera faite par la servlet suivante ==>

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
public class ConfirmationDemandeProjet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
 
		HttpSession session = request.getSession(true);		  
		// Recupere l'email de l'utilisateur 
		String emailconfirmant = request.getParameter("email");
		System.out.println(emailconfirmant);
		PersonneDAO dao = new PersonneDAO();
		List candidatconfirme = dao.findByEmail(emailconfirmant);
 
		if (candidatconfirme.size()!=0) {
			Personne candidat = (Personne) candidatconfirme.get(0);
 
		candidat.setConfirme("oui");
 
 
		Transaction tx = dao.getSession().beginTransaction();
		dao.save(candidat);
		tx.commit();
		dao.getSession().close();
 
		EnregistrementSociete enr = new EnregistrementSociete();
		enr.confirmationMessage(candidat.getEmail());enr.confirmationMessageAdmin();
 
		getServletContext().getRequestDispatcher("/MaJSFCandidat.faces").forward(request,response);
		}
	}

Puis par persistance des données, on donne l'acces par candidat.setConfirme("oui").

Puis grace à

Code :

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

getServletContext().getRequestDispatcher("/MaJSFCandidat.jsp").forward(request,response);

on affiche pour le client qu'il est bien enregistrer.

Voila le fruit de longues recherches sur google, qui j'espère profitera pleinnement à ceux qui apprennent.

Pour comprendre le fonctionnement de java mail 1.3 voir http://www.supinfo-projects.com/fr/2004/javamail/ dans lequel j'ai puisser le code d'envoi de mail, mais le reste c'est bien moi qui l'ai fait

Vous avez le même processuse sur mon site http://www.visioclear.fr/
Mettez une vraie adresse email. et vous recevrez la demande de confirmation voila.

millie · 18/06/2008, 16h06

Bibliothèque : JMF (Multimédia)
Auteur : millie
Titre: Récuperation des données sur les pistes (audio/vidéo) d'un fichier multimédia avec JMF.

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
/**
 * 
 */
package media;
 
import java.io.IOException;
 
import javax.media.CannotRealizeException;
import javax.media.Format;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.NoPlayerException;
import javax.media.Processor;
import javax.media.control.TrackControl;
import javax.media.format.AudioFormat;
import javax.media.format.VideoFormat;
 
/**
 * @author millie
 * 
 */
public class Main {
 
	static boolean waitState(Processor processor, int state) {
		boolean transition = false;
		Object object = new Object();
 
		synchronized (object) {
			try {
				while (processor.getState() != state)
					object.wait(1000);
				transition = true;
			} catch (Exception e) {
			}
 
		}
 
		return transition;
	}
 
	/**
	 * @param args
	 * @throws IOException
	 * @throws NoPlayerException
	 * @throws CannotRealizeException
	 */
	public static void main(String[] args) throws NoPlayerException,
			IOException, CannotRealizeException {
 
		MediaLocator mediaLocaltor = new MediaLocator(
				"file://C:/tmp/workspace/Media/video/test_ecoles.avi");
 
 
		Processor processor = Manager.createProcessor(mediaLocaltor);
 
		processor.realize();
		if (!waitState(processor, Processor.Realized)) {
			System.err.println("Failed");
			return;
		}
 
		double timeD = processor.getDuration().getSeconds();
 
		System.out.println("Durée : " + (int) timeD);
 
		System.out.println("Content descriptor : "
				+ processor.getContentDescriptor().toString());
 
		TrackControl[] tracks = processor.getTrackControls();
 
		for (int i = 0; i < tracks.length; i++) {
 
			Format format = tracks[i].getFormat();
			System.out.println(format.toString());
			if (format instanceof VideoFormat) {
				VideoFormat videoFormat = (VideoFormat) format;
				System.out.println("Video Format : ");
				System.out
						.println(" * Encoding : " + videoFormat.getEncoding());
				System.out.println(" * Framerate : "
						+ videoFormat.getFrameRate());
				System.out.println(" * Max data lenght : "
						+ videoFormat.getMaxDataLength());
				System.out.println(" * Size largeur : : "
						+ videoFormat.getSize().getWidth());
				System.out.println(" * Size hauteur : : "
						+ videoFormat.getSize().getHeight());
 
			}
 
			if (format instanceof AudioFormat) {
 
				System.out.println("Audio Format : ");
				AudioFormat audioFormat = (AudioFormat) format;
				System.out
						.println(" * Encoding : " + audioFormat.getEncoding());
				System.out
						.println(" * Channels : " + audioFormat.getChannels());
				System.out.println(" * FrameSizeInBits : "
						+ audioFormat.getFrameSizeInBits());
				System.out.println(" * Endian : " + audioFormat.getEndian());
				System.out.println(" * Signed : " + audioFormat.getSigned());
				System.out.println(" * SampleRate Hz : "
						+ audioFormat.getSampleRate());
				System.out.println(" s* SampleSizeInBit : "
						+ audioFormat.getSampleSizeInBits());
				System.out.println(" * FrameRate : "
						+ audioFormat.getFrameRate());
 
			}
 
		}
 
		processor.deallocate();
		processor.close();
		System.out.println("Fini");
 
	}
 
}

Razgriz · 22/06/2008, 14h28

Pas mal cette dernière classe sur JMF millie, en voici une qui permet de lire n'importe quel fichier audio, pour peu d'avoir inclu les jars nécéssaires aux codecs.

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
 
/**
 * File AudioFileReader.java
 * Created on 30 mai 2008
 */
package util;
 
import java.io.File;
import java.io.IOException;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
 
/**
 *
 * @author Absil Romain.
 */
public class AudioFileReader
{
 
    public AudioFileReader()
    {
    }
 
    public static void readAudioFile(File file) 
            throws UnsupportedAudioFileException, IOException, 
                LineUnavailableException
    {
        AudioInputStream in = AudioSystem.getAudioInputStream(file);
        AudioInputStream din = null;
        AudioFormat baseFormat = in.getFormat();
        AudioFormat decodedFormat =
                new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                baseFormat.getSampleRate(),
                16,
                baseFormat.getChannels(),
                baseFormat.getChannels() * 2,
                baseFormat.getSampleRate(),
                false);
        din = AudioSystem.getAudioInputStream(decodedFormat, in);
 
        rawplay(decodedFormat, din);
        in.close();
    }
 
    public static void rawplay(AudioFormat targetFormat, AudioInputStream din)
            throws IOException, LineUnavailableException
    {
        byte[] data = new byte[4096];
        SourceDataLine line = getLine(targetFormat);
        if (line != null)
        {
            // Start
            line.start();
            int nBytesRead = 0, nBytesWritten = 0;
            while (nBytesRead != -1)
            {
                nBytesRead = din.read(data, 0, data.length);
                if (nBytesRead != -1)
                    nBytesWritten = line.write(data, 0, nBytesRead);
            }
            // Stop
            line.drain();
            line.stop();
            line.close();
            din.close();
        }
    }
 
    public static SourceDataLine getLine(AudioFormat audioFormat)
            throws LineUnavailableException
    {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);
        res.open(audioFormat);
        return res;
    }
}

millie · 22/06/2008, 18h34

Citation:

Envoyé par Razgriz

Pas mal cette dernière classe sur JMF millie, en voici une qui permet de lire n'importe quel fichier audio, pour peu d'avoir inclu les jars nécéssaires aux codecs.

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
 
/**
 * File AudioFileReader.java
 * Created on 30 mai 2008
 */
package util;
 
import java.io.File;
import java.io.IOException;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
 
/**
 *
 * @author Absil Romain.
 */
public class AudioFileReader
{
 
    public AudioFileReader()
    {
    }
 
    public static void readAudioFile(File file) 
            throws UnsupportedAudioFileException, IOException, 
                LineUnavailableException
    {
        AudioInputStream in = AudioSystem.getAudioInputStream(file);
        AudioInputStream din = null;
        AudioFormat baseFormat = in.getFormat();
        AudioFormat decodedFormat =
                new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
                baseFormat.getSampleRate(),
                16,
                baseFormat.getChannels(),
                baseFormat.getChannels() * 2,
                baseFormat.getSampleRate(),
                false);
        din = AudioSystem.getAudioInputStream(decodedFormat, in);
 
        rawplay(decodedFormat, din);
        in.close();
    }
 
    public static void rawplay(AudioFormat targetFormat, AudioInputStream din)
            throws IOException, LineUnavailableException
    {
        byte[] data = new byte[4096];
        SourceDataLine line = getLine(targetFormat);
        if (line != null)
        {
            // Start
            line.start();
            int nBytesRead = 0, nBytesWritten = 0;
            while (nBytesRead != -1)
            {
                nBytesRead = din.read(data, 0, data.length);
                if (nBytesRead != -1)
                    nBytesWritten = line.write(data, 0, nBytesRead);
            }
            // Stop
            line.drain();
            line.stop();
            line.close();
            din.close();
        }
    }
 
    public static SourceDataLine getLine(AudioFormat audioFormat)
            throws LineUnavailableException
    {
        SourceDataLine res = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
        res = (SourceDataLine) AudioSystem.getLine(info);
        res.open(audioFormat);
        return res;
    }
}

Une version extraite des sources Audio donne une taille de buffer optimisée pour mettre dans le buffer 100ms à tous les coups :

Code :

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

1
2
3
		// 100 ms buffer for real time change to the sound stream
		int bufferSize = format.getFrameSize() * Math.round(format.getSampleRate() / 10);
		byte[] buffer = new byte[bufferSize];

J'avais vu ça là : http://java.developpez.com/sources/?...#echoJavasound

kmdkaci · 01/10/2008, 17h43

Cette contribution, toute modeste permet de comprendre quelques concepts de l’interface graphique en Java.
J’ai réalisé cette classe en m’inspirant du précieux document «Programmation Java pour les enfants, les parents et les grands-parents». J’ai trouvé intéressant de le compléter par ce programme qui consiste à réaliser une calculatrice à opérations simples. D’ailleurs un exemple de calculatrice a été expliqué dans ce tutoriel. Ce programme est en quelque sorte un complément de ce cas pratique.
J’espère que j’ai bien commenté les lignes de code pour que ce programme soit compris par des débutants et par tous ceux qui peuvent en trouver une piste ou quelconque solution à leurs développements…
Important : ne pas oublier de copier dans le même répertoire l'icone calculatrice.png ou de la créer. Cette icone est jointe dans ce document.

Titre : Calculatrice à opérations simples
Auteur : kmdkaci
Champ d'application : Interface graphique. Niveau : débutant

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
 
import javax.swing.*;
import java.awt.*;
import java.awt.event.*; //Pour les événements
 
public class Calculatrice extends JFrame  implements ActionListener
 
{
    JPanel pChiffre = new JPanel(); //Panel qui contient les chiffres
    JPanel pSigne = new JPanel();   //Panel des opérateurs (+/*-=)
    JPanel pSaisie = new JPanel(); //Panel pour le champ de saisie.
 
    //Declaration des bouttons
    JButton bUn = new  JButton("1");
    JButton bDeux = new  JButton("2");
    JButton bTrois = new  JButton("3");
    JButton bQuatre = new  JButton("4");
    JButton bCinq = new  JButton("5");
    JButton bSix = new  JButton("6");
    JButton bSept = new  JButton("7");
    JButton bHuit = new  JButton("8");
    JButton bNeuf = new  JButton("9");
    JButton bZero = new  JButton("0");
    JButton bPoint = new  JButton(".");
    JButton bEgal = new  JButton("=");
    JButton bMoins = new  JButton("-");
    JButton bPlus = new  JButton("+");
    JButton bFois = new  JButton("*");
    JButton bDiv = new  JButton("/");
    JButton bC = new  JButton("C");
    JButton bAbout = new JButton("?");
    TextField cSaisie = new TextField(20); //Zone de saisie
 
    JDialog aPropos = new JDialog(); //Boite A Propos de
 
    //Ce tableau sert à stocker les saisies
   //Entre les opérateurs et les chiffres, la taille doit être inférieure à 20 éléments
    //Vous pouvez bien sur modifier cette valeur.
    private String[] stocRes = new String[20];
 
    private int i = 0;
 
    static final int LARGEUR =  210;
    static final int LONGUEUR =  215;
 
    //cRes est une variable qui permet de stocker l’expression à évaluer
    private String cRes = "";
 
    //Prend Vraie si une erreur s'est produite
    private boolean erreur = false;
 
    public Calculatrice()
    {
      //On définit l'événement de fermeture de la fenêtre grâce à WindowAdapter
      WindowAdapter win = new WindowAdapter()
      {
        public void windowClosing(WindowEvent e)
        //Si on clique sur le bouton fermeture, on quitte le programme
        {System.exit(0);}
      };
 
      //On ajoute l'événement à notre fenêtre.
      addWindowListener(win);
 
        //On définit les événements pour les boutons.
        bUn.addActionListener(this);
        bDeux.addActionListener(this);
        bTrois.addActionListener(this);
        bQuatre.addActionListener(this);
        bCinq.addActionListener(this);
        bSix.addActionListener(this);
        bSept.addActionListener(this);
        bHuit.addActionListener(this);
        bNeuf.addActionListener(this);
        bPlus.addActionListener(this);
        bMoins.addActionListener(this);
        bDiv.addActionListener(this);
        bFois.addActionListener(this);
        bZero.addActionListener(this);
        bEgal.addActionListener(this);
        bC.addActionListener(this);
        bPoint.addActionListener(this);
        bAbout.addActionListener(this);
 
      //On appelle la fonction afficher
      afficher();
    }
 
     //Cette méthode permet de construire l'interface graphique
     public void afficher()
     {
        setSize(LARGEUR,LONGUEUR); //Fixer la taille
        setResizable(false); //Empêcher le redimensionnement de la fenêtre
        setTitle("Calculatrice");  //Titre de la fenêtre
        setLocationRelativeTo(null); //centrer la fenêtre
 
        //Déclaration de la fenêtre A propos
        JLabel label1 = new JLabel("                                 Developpez.com            ");
        JLabel label2 = new JLabel("                    Calculatrice à opèrations simples      ");
 
        //On affiche les labels sur deux 2 colonnes.
        //On définit le Layout comme GridLayout
        aPropos.getContentPane().setLayout(new GridLayout(2,1));
        aPropos.getContentPane().add(label1);
        aPropos.getContentPane().add(label2);
 
        //On fixe sa taille, son titre, empêcher le redimensionnement
        aPropos.setSize(320,150);
        aPropos.setTitle("A propos de ");
        aPropos.setResizable(false);
 
        //On l'affiche au milieu de l'écran
        aPropos.setLocationRelativeTo(null);
 
        //On associe à nos fenêtres une icone calculatrice.png (qui est dans le répertoire courant)
        Image icon = Toolkit.getDefaultToolkit().getImage(getClass().getClassLoader().getResource("./calculatrice.png"));
        setIconImage(icon);
 
        //On définit le conteneur pour la forme principale
        Container conteneur = getContentPane();
 
        //On lui fixe un BorderLayout. Dans la zone nord on affiche le champ de saisie
        //Au centre, on affiche les chiffres, et à l'est on affiche les opérateurs (signes).
        BorderLayout disposition = new BorderLayout();
        conteneur.setLayout(disposition);
 
        //On définit une font pour le champ de saisie.
       //On peut aussi laisser la font par défaut.
        Font font = new Font("TimesNewRoman",Font.BOLD,15);
        cSaisie.setFont(font );
 
        //On désactive le champ de saisie pour la saisie avec le clavier
        cSaisie.setEnabled(false);
 
        //On ajoute le champ cSaisie au panel pSaisie dans la partie nord du panel
        pSaisie.add(cSaisie);
        conteneur.add("North",pSaisie );
 
        //On ajoute les boutons des chiffres au panel pChiffre
        pChiffre.add(bUn);
        pChiffre.add(bDeux);
        pChiffre.add(bTrois);
        pChiffre.add(bQuatre);
        pChiffre.add(bCinq);
        pChiffre.add(bSix);
        pChiffre.add(bSept);
        pChiffre.add(bHuit);
        pChiffre.add(bNeuf);
        pChiffre.add(bZero);
        pChiffre.add(bPoint);
        pChiffre.add(bC);
        pChiffre.add(bAbout);
 
        //On définit le Layout de disposition pour pChiffre
        // 5 lignes et 3 colonnes, puis on ajoute le panel pChiffre dans la zone Centre du conteneur général
        GridLayout dispositionChiffres = new GridLayout(5, 3);
        pChiffre.setLayout(dispositionChiffres);
        conteneur.add("Center",pChiffre );
 
        //On ajoute les opérateurs au panel pSigne
        pSigne.add(bDiv);
        pSigne.add(bFois);
        pSigne.add(bMoins);
        pSigne.add(bPlus);
        pSigne.add(bEgal);
 
        //On lui definit la disposition GridLayout
        // soit à déposer en 5 ligne et une seule colonne
        GridLayout dispositionSignes = new GridLayout(5,1);
        pSigne.setLayout(dispositionSignes);
 
        //On ajoute pSigne à l'est du panel général
        conteneur.add("East",pSigne);
      }
 
       public void actionPerformed(ActionEvent evt)
          {
             String operateur = "+-*/"; //Les opérateurs
             String chiffres = "0123456789."; //Les chiffres
 
            //cas où on a appuyé sur un bouton chiffre
            //on cumule la saisie dans la variable cRes
            //Ex. si on a appuyé sur 2 puis sur 5, on aura la chaine "25"  dansla variable cRes
             if ( chiffres.indexOf(evt.getActionCommand()) != -1 )
             {
                  //X.indexOf(Y) renvoie la position de Y dans X, et renvoie -1 si Y ne se trouve pas dans X
                  cRes = cRes + evt.getActionCommand(); // getActionCommand donne le contenu du bouton.
                  cSaisie.setText(cRes); //On l'affiche
             }
 
             else  // Si le boutton de l'événement est un operateur
             if ( operateur.indexOf(evt.getActionCommand()) != -1 )
             {
                  //On stocke toute la chaine correspondante au chiffre saisie dans un élément du tableau
                  stocRes[i] = cRes;
                  i++; //On incremente l'indice
                  stocRes[i] = evt.getActionCommand(); //Puis on sauvegrade l'operateur
                  i++; //on avance dans le tableau
                  cRes = ""; //Puis on remis la variable qui stocke la chaine à vide.
             }
             else  //cas où on a appuyé sur le boutton =
             if ( evt.getActionCommand().equals("=") )
             {
                  double leResultat = 0;
                  //Cas particulier :
                  //Si on a rien saisi, on initialise la variable cRes à 0
                  if ( cRes.equals("") )
                  {
                    cRes = "0";
                  }
                  stocRes[i] = cRes;
                  i++;
 
                  //On calcule l'expression via la méthode calculer()
                  leResultat = calculer();
 
                  //S'il y a erreur on affiche le message Erreur comme résultat
                  if ( erreur )
                  {
                    cSaisie.setText("Erreur ");
                  }
                  else
                  { //Sinon on affiche la variable leResultat renvoyée par la fonction calculer()
                    cSaisie.setText(""+leResultat);
                  }
             }
             else
             //cas où on a appuyé sur le bouton 'C'
             if ( evt.getActionCommand().equals("C")  ) {
                  //On initialise cRes et on vide le tableau stocRes via la méthode vidertableau()
                  cRes = "0";
                  cSaisie.setText(cRes);
                  vidertableau();
             }
             else  //cas où on a appuyé sur le bouton '?'
                  //On affiche la boite A propos
             if ( evt.getActionCommand().equals("?") )
             {
                aPropos.setVisible(true);
             }
          }
 
          //Cette méthode évolue l'expression contenue dans le tableau stockRes
          public double calculer()
          {
            erreur = false; //Par défaut, il n y a pas d'erreur
            double resultat = 0;
            try
            {
            //On initialise le résultat au premier élément du tableau
            resultat = Double.parseDouble(stocRes[0]);
 
            //Si l'exception est rencontré la variable erreur est mise à true
            } catch(Exception e)
              {
                erreur = true;
                return 0;
              }
 
            // On parcoure le tableau et on procède comme suit pour évoluer l'expression :
            // soit cette expression à évoluer : 45+32-7
            // le résultat est initialisé au premier élément soit : 45, puis on rencontre un operateur (+) dans notre cas.
            // On somme la variable resultat avec stocRes[j+1], c'est à dire l'élément qui vient après l'operateur, soit 45+32
            // et on le met dans resultat, soit 77, puis on rencontre l'opérateur "-" et on évolue l'expréssion par (resultat - 7)
            // soit 77-7. et on met 70 dans la variable resultat.
            // l'opération varie bien sur selon l'operateur rencontré
             for(int j=0; j<= i-1; j++)
             {
                  try
                  {   //Opérateur + rencontré
                      if ( stocRes[j].equals("+") )
                      {
                        resultat = resultat + Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }else
                      //Opérateur - rencontré
                      if ( stocRes[j].equals("-") )
                      {
                        resultat = resultat - Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }else
                      //Opérateur * rencontré
                      if ( stocRes[j].equals("*") )
                      {
                        resultat = resultat * Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }else
                      //Opérateur / rencontré
                      if ( stocRes[j].equals("/") )
                      {
                        resultat = resultat / Double.parseDouble(stocRes [j+1]) ;
                        j++;
                      }
                  }catch (Exception e)
                    {
                      erreur = true; //Il ya une erreur quelques part, on initialise erreur à true
                      resultat = 0;
                      //Attention l'expression doit être correcte pour l'évaluer sans erreur
                    }
             }
             return resultat;
          }
 
          //Cette méthode vide le tableau stockRes
          public void vidertableau()
          {
              for ( int j = 0; j<= stocRes.length-1;j++ )
              {
                stocRes[j] = "";
                i=0;
              }
          }
 
    public static void main(String[] args)
     {
       new Calculatrice().setVisible(true);
     }
 
  }

ggorson · 16/10/2008, 23h12

Une méthode super simple pour afficher un nombre sur un certain nombre de caractères et de remplir avec des zéros les caractères vides.

Exemple:

Citation:

Afficher 35 sur 6 caractères.

On doit obtenir « 000035 ».

Code :

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

1
2
3
4
 
public String fillZero(long i, int length){
return (length>Long.toString(i).length())?"0"+fillZero(i,length-1):Long.toString(i);
}

La puissance des algorithmes récursifs et en une seule ligne!
Il y a d'autres méthodes, mais mon benchmark montre que c'est plus rapide.

http://www.genericsystem.com/web/act...ites/fill-zero

®om · 16/10/2008, 23h29

Citation:

Envoyé par ggorson

Une méthode super simple pour afficher un nombre sur un certain nombre de caractères et de remplir avec des zéros les caractères vides.

Exemple:

Code :

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

1
2
3
4
 
public String fillZero(long i, int length){
return (length>Long.toString(i).length())?"0"+fillZero(i,length-1):Long.toString(i);
}

La puissance des algorithmes récursifs et en une seule ligne!
Il y a d'autres méthodes, mais mon benchmark montre que c'est plus rapide.

http://www.genericsystem.com/web/act...ites/fill-zero

Une récursive en java avec concaténation de Strings, ça doit pas être le plus rapide?

Sérieusement, une méthode avec StringBuilder, ou meme remplir soi-même un tableau doit être bien plus rapide

adiGuba · 16/10/2008, 23h40

Citation:

Envoyé par ggorson

La puissance des algorithmes récursifs et en une seule ligne!
Il y a d'autres méthodes, mais mon benchmark montre que c'est plus rapide.

Et qu'en est-il de celle-ci :

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
	public static String fillZero(long i, int length) {
		// On convertie en String de manière tout à fait normale :
		String str = Long.toString(i);
		final int strLen = str.length();
		// Si la chaine est plus courte que la taille voulu
		if (strLen<length) {
			// On crée un nouveau buffer à la taille voulu :
			final char[] cbuf = new char[length];
			// On remplaces les éléments manquants par des zéros :
			Arrays.fill(cbuf, 0, length-strLen, '0');
			// Et on recopies les chars de la chaine qu'on a créé :
			str.getChars(0, strLen, cbuf, length-strLen);
			// Juste avant de recréer une nouvelle String :
			str = new String(cbuf);
		}
		return str;
	}

Pas de récursion (donc pas de multiplication des appels de méthodes, ni des variables temporaires).

a++

®om · 17/10/2008, 00h14

Merci adiGuba, j'ai eu la flemme

ggorson · 17/10/2008, 15h31

Citation:

Envoyé par adiGuba

Et qu'en est-il de celle-ci :
[...]

Pas de récursion (donc pas de multiplication des appels de méthodes, ni des variables temporaires).

a++

J'ai refait mon benchmark en incluant ta méthode...
et le résultat est sans appel: elle est deux fois plus rapide.

Voir le benchmark que j'ai publié ici

Merci adiGuba pour cette belle idée.

adiGuba · 17/10/2008, 15h44

Citation:

Envoyé par ggorson

J'ai refait mon benchmark en incluant ta méthode...
et le résultat est sans appel: elle est deux fois plus rapide.

En même temps, et même si elle doit être beaucoup moins performante (car beaucoup plus puissante), je préfères quand même de loin utiliser String.format() et sa syntaxe à la printf()...

Car une différence de quelques millisecondes sur près d'un million d'appel c'est vraiment négligeable dans la plupart des applications (à part si on fait des traitements intensives).

a++

anadoncamille · 20/01/2009, 17h47

Salut,

voici une frame qui passe en plein écran et qui n'utilise pas le thread d'affichage d'awt. Ainsi vous pouvez faire du monotache plein écran (dit comme ça c'est peu engageant, mais pour faire du jeu vidéo c'est très pratique). Par défaut, Alt-F4 permet de quitter.

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
import java.awt.*;
import javax.swing.*;
import java.awt.image.*;
import java.awt.event.*;
 
public class FullScreenFrame extends JFrame {
 
  // Pour initialiser l'application
  public static void main(String[] args) {
    FullScreenFrame fsf = new FullScreenFrame();
    while (true)
      fsf.turn();
  }
 
  private static final int D_WIDTH = 1024;
  private static final int D_HEIGHT = 768;
  private static final int D_DEPTH = 32;
  private static final int BUFFERS = 3;
  private static final Cursor hiddenCursor = Toolkit.getDefaultToolkit().createCustomCursor(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB), new Point() , "");
  private static final Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
 
  private boolean close;
  private BufferStrategy buffStrat;
  private Rectangle drawBounds;
  private Cursor currentCursor;
  private KeyListener keyListener;
  private MouseListener mouseListener;
  private MouseMotionListener mouseMotionListener;
  private MouseWheelListener mouseWheelListener;
 
  // Constructeur avec paramètres par défaut
  public FullScreenFrame() {
    this(D_WIDTH, D_HEIGHT, D_DEPTH);
  }
 
  // Constructeur
  public FullScreenFrame(int width, int height, int depth) {
    super(""); // Le titre ne sera pas visible
    close = false; // Indicateur de fermeture de fenêtre : fenêtre ouverte
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Alt-F4 : quitter
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        close = true; // Indicateur de fermeture de fenêtre : fermeture fenêtre
      }
    });
    setUndecorated(true); // Pas de bordures ni boutons
    setResizable(false); // Interdiction de changement de taille
    setFocusable(true); // Peut recevoir lengthfocus clavier
    setVisible(true); // Est visible
    setFocusTraversalKeysEnabled(false); // Recevoir les touches de gestion du focus (tab)
    requestFocus(); // Demander le focus clavier
    DisplayMode displayMode = getNearestCompatibleDisplayMode(width, height, depth); // Mode d'affichage le plus adapté
    setFullScreen(this, displayMode); // Passage en plein écran
    createBufferStrategy(BUFFERS); // Stratégie de gestion mémoire graphique : cycle de 3 buffers
    buffStrat = getBufferStrategy(); // Récupération de la stratégie de rafraîchissement
    drawBounds = getBounds(); // Zone affichable
    keyListener = new KeyAdapter() {}; // Gestion clavier
    mouseListener = new MouseAdapter() {}; // Gestion souris
    mouseMotionListener = new MouseMotionAdapter() {};
    mouseWheelListener = new MouseWheelListener() { public void mouseWheelMoved(MouseWheelEvent e){} };
    addKeyListener(keyListener);
    addMouseListener(mouseListener);
    addMouseMotionListener(mouseMotionListener);
    addMouseWheelListener(mouseWheelListener);
  }
 
  // Méthode pour gérer les paramètres de l'application
  public void live() {
  }
 
  // Méthode pour dessiner l'application
  public void draw(Graphics2D g, Rectangle r) {
    g.setColor(Color.pink);
    g.fill(r);
  }
 
  // Un tour de calculs pour la fenêtre et l'application associée
  public void turn() {
    live(); // calcul paramètres
    draw((Graphics2D)buffStrat.getDrawGraphics(), drawBounds); // affichage
    if ((!buffStrat.contentsLost()) && (!buffStrat.contentsRestored())) // si la mémoire graphique est correcte
      buffStrat.show(); // afficher lengthcontenu de la mémoire graphique
    if (close) // si fenêtre en cours de fermeture
      processClose(); // fermer
  }
 
  // fermeture de la fenêtre
  private void processClose() {
    setStartingDisplayMode(); // retour au mode d'affichage initial
    setCursor(null); // curseur par défaut
    dispose(); // libérer les ressources de la frame
    System.exit(0); // sortir
  }
 
// Affichage du curseur souris =================================================  
 
  public void setCursor(Cursor c) {
    if (c == currentCursor)
      return;
    super.setCursor(c);
    currentCursor = c;
  }
 
  public void hideCursor() {
    setCursor(hiddenCursor);
  }
 
  public void showCursor() {
    setCursor(defaultCursor);
  }
 
// Gestion des modes d'affichage et du plein écran =============================
 
  private static GraphicsDevice graphicsDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
  private static DisplayMode startingDisplayMode = graphicsDevice.getDisplayMode();
  private static DisplayMode currentDisplayMode = graphicsDevice.getDisplayMode();
  private static DisplayMode[] availableDisplayModes = graphicsDevice.getDisplayModes();
  private static GraphicsConfiguration[] availableGraphicsConfigurations = graphicsDevice.getConfigurations();
 
  public static int getDefaultWidth() {
    return startingDisplayMode.getWidth();
  }
 
  public static int getDefaultHeight() {
    return startingDisplayMode.getHeight();
  }
 
  private static double getDefaultRatio() {
    return (double)getDefaultWidth() / (double)getDefaultHeight();
  }
 
  private static int getDefaultBitDepth() {
    return startingDisplayMode.getBitDepth();
  }
 
  public static DisplayMode getNearestCompatibleDisplayMode(int width, int height) {
    return getNearestCompatibleDisplayMode(width, height, getDefaultBitDepth());
  }
 
  public static DisplayMode getNearestCompatibleDisplayMode(int width, int height, int bitDepth) {
    return getNearestCompatibleDisplayMode(width, height, bitDepth, false);
  }
 
  private static DisplayMode getNearestCompatibleDisplayMode(int width, int height, int bitDepth, boolean keepRatio) {
    DisplayMode bestDisplayMode = startingDisplayMode;
    double ratio = getDefaultRatio();
 
    int dx = getDefaultWidth() - width;
    int dy = getDefaultHeight() - height;
    int d = Integer.MAX_VALUE;
    if ((dx >=0) && (dy >= 0))
      d = dx + dy;
    int bestD = d;
 
    int n = availableDisplayModes.length;
    DisplayMode dm;
    double r;
    for (int i = 0 ; i < n ; i++) {
      dm = availableDisplayModes[i];
      r = (double)dm.getWidth() / (double)dm.getHeight();
      if (((r == ratio) || (!keepRatio)) && (dm.getBitDepth() >= bitDepth)) {
        dx = dm.getWidth() - width;
        dy = dm.getHeight() - height;
        d = Integer.MAX_VALUE;
        if ((dx >=0) && (dy >= 0))
          d = dx + dy;
        if (d <= bestD) {
          bestDisplayMode = dm;
          bestD = d;
        }
      }
    }
    return bestDisplayMode;
  }
 
  public static boolean setFullScreen(Window wi, DisplayMode dm) {
    boolean ok = graphicsDevice.isFullScreenSupported();
    System.out.println("Full screen supported    : " + ok);
    if (ok)
      graphicsDevice.setFullScreenWindow(wi);
    else
      return false;
    ok = graphicsDevice.isDisplayChangeSupported();
    System.out.println("Display change supported : " + ok);
    if (ok) {
      try {
        graphicsDevice.setDisplayMode(dm);
      }
      catch (Exception e) {
        currentDisplayMode = startingDisplayMode;
        graphicsDevice.setDisplayMode(startingDisplayMode);
        graphicsDevice.setFullScreenWindow(null);
        return false;
      }
    }
    else
      return false;
    currentDisplayMode = dm;
    return true;
  }
 
  public static void setStartingDisplayMode() {
    if (currentDisplayMode == startingDisplayMode)
      return;
    currentDisplayMode = startingDisplayMode;
    graphicsDevice.setDisplayMode(startingDisplayMode);
    graphicsDevice.setFullScreenWindow(null);
  }
 
}

Pour un exemple d'utilisation, le classique Hello World remasterisé en Dolby Surround :

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
 
import java.awt.*;
import java.awt.event.*;
 
public class HelloWorld extends FullScreenFrame implements MouseMotionListener {
 
  public static void main(String[] args) {
    HelloWorld hello = new HelloWorld();
    while (true)
      hello.turn();
  }
 
  private int frames;
  private long startDate;
  private double fps;
  private int xMouse;
  private int yMouse;
 
  public HelloWorld() {
    super(640, 480, 32);
    frames = 0;
    startDate = System.currentTimeMillis();
 
    addMouseMotionListener(this);
//    hideCursor();
  }
 
  public void live() {
    frames++;
    fps = (double)frames * 1000d / (double)(System.currentTimeMillis() - startDate);
  }
 
  public void draw(Graphics2D g, Rectangle r) {
    super.draw(g,r);
    g.setColor(Color.blue);
    g.drawString("HELLO WORLD", r.width / 3, r.height / 3);
    g.drawString("(Alt-F4 pour quitter)", r.width / 3, r.height / 3 + 20);
    g.drawString("fps : " + fps, xMouse, yMouse);
    g.drawString("2009, Sylvain Tournois - http://sylv.tournois.free.fr/", 0, r.height - 33);
  }
 
  public void mouseMoved(java.awt.event.MouseEvent mouseEvent) {
    xMouse = mouseEvent.getX();
    yMouse = mouseEvent.getY();
  }
 
  public void mouseDragged(java.awt.event.MouseEvent mouseEvent) {
  }
 
}

anadoncamille · 26/01/2009, 13h14

Bonjour,

voici une des classes dont j'utilise le plus souvent les services dans mes projets. C'est un Mini-OS regroupant des services bien utiles :

- recherche de fichiers
- copie et création de fichiers
- effacement de fichiers
- deltree
- nettoyage de disque
- zip
- unzip

Le voici, il n'est pas très commenté mais très fonctionnel et disponible :

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
 
import java.io.*;
import java.util.*;
import java.text.*;
import java.util.zip.*;
 
public class MiniOS {
 
  // nettoie les disques c, d, e et f
  public static void main(String[] args) {
    String f0 = "monFichier.mp3"; // Un gros fichier (2 - 10 Mo)
    String f1 = "monFichier.jpg"; // Un fichier moyen (20 - 100 Ko)
    String f2 = "monFichier.txt"; // Un petit fichier (1 octet)
    cleanEmptySpaces("c", false, f0, f1, f2); // Remplit c:
    cleanEmptySpaces("d", false, f0, f1, f2); // Remplit d:
    cleanEmptySpaces("e", false, f0, f1, f2); // Remplit e:
    cleanEmptySpaces("f", false, f0, f1, f2); // Remplit f:
    delTree("c:\temp"); // Libère c:
    delTree("d:\temp"); // Libère d:
    delTree("e:\temp"); // Libère e:
    delTree("f:\temp"); // Libère f:
  }
 
  // nettoie un disque, si solo=true le répertoire temp est supprimé directement, 
  // sinon l'algorithme est plus efficace avec plusieurs lecteurs en faisant 
  // les effacements en groupé à la fin
  public static void cleanEmptySpaces(String diskLetter, boolean solo, String f0, String f1, String f2) {
    System.out.println("\nRC Pro __oPRo__ :\n=================\n\nScan de " + diskLetter + ":");
    String d = diskLetter + ":/temp";
    System.out.print("Ecrasemment :  ");
    String[] cs = {"\\", "|", "/", "-"};
    int i = 0;
    while (writeTempFile(f0, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f1, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f2, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    System.out.println("\baplani.");
    if (solo)
      delTree(d);
  }
 
  // Copie un fichier dans le répertoire temp
  public static boolean writeTempFile(String sourceFile, String diskLetter) {
    return copyFile(sourceFile, diskLetter + ":/temp/FNEC_" + System.currentTimeMillis() + ".tmp", false);
  }
 
  // Copie un fichier src dans dst
  public static boolean copyFile(String src, String dst) {
    return copyFile(src, dst, true);
  }
 
  // Copie un fichier src dans dst, renvoie false si la copie a échoué
  public static boolean copyFile(String src, String dst, boolean verbose) {
    try {
      RandomAccessFile raf = new RandomAccessFile(src, "r");
      int n = (int)raf.length();
      byte[] data = new byte[n];
      raf.readFully(data);
      raf.close();
      createFile(dst);
      raf = new RandomAccessFile(dst, "rw");
      raf.setLength(0);
      raf.write(data);
      raf.close();
    }
    catch (Exception e) {
	  if (verbose)
        e.printStackTrace();
	  return false;
    }
	return true;
  }
 
  // Copie de src dans dst les fichiers *.*
  public static void copyDirectory(String src, String dst) {
    System.out.println("Copying tree " + src + " in " + dst);
    copyDirectory(src, dst, "*");
  }
 
  // Copie de src dans dst les fichiers *.extension
  public static void copyDirectory(String src, String dst, String ext) {
    copyDirectory(src, dst, "", ext);
  }
 
  // Copie de src dans dst les fichiers start*.extension
  public static void copyDirectory(String src, String dst, String start, String ext) {
    Vector v = getFileList(src, start, ext);
    int n = v.size();
    String s;
    String d;
    for (int i = 0 ; i < n ; i++) {
      s = (String)v.get(i);
      d = dst + s.substring(src.length());
      copyFile(s, d);
      printPercent(i, n);
    }
  }
 
  // Efface directory et son contenu
  public static void delTree(String directory) {
    System.out.println("Deleting tree " + directory);
    deleteFiles(directory, "*");
    deleteDirectory(directory);
  }
 
  // Efface *.* dans directory
  public static void deleteFiles(String directory) {
    deleteFiles(directory, "*");
  }
 
  // Efface *.extension dans directory
  public static void deleteFiles(String directory, String extension) {
    deleteFiles(directory, "", extension);
  }
 
  // Efface start*.extension dans directory
  public static void deleteFiles(String directory, String start, String extension) {
    System.out.println("Deleting " + directory + "/" + start + "*." + extension);
    File f;
    Vector v = getFileList(directory, start, extension);
    int n = v.size();
    for (int i = 0 ; i < n ; i++) {
      f = new File((String)v.get(i));
      f.delete();
      printPercent(i, n);
    }
  }
 
  // Efface un fichier
  public static void deleteFile(String s) {
    System.out.println("Deleting " + s);
    File f = new File(s);
    f.delete();
  }
 
  // Renvoie la liste des dossiers dans directory
  public static Vector getDirectoryList(String directory) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.add(list[i].getName());
    return result;
  }
 
  // Renvoie la liste de *.extension dans directory
  public static Vector getFileList(String directory, String extension) {
    return getFileList(directory, "", extension);
  }
 
  // Renvoie la liste de start*.extension dans directory
  public static Vector getFileList(String directory, String start, String extension) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.addAll(getFileList(f.getPath() + "\\" + list[i].getName(), extension));
    list = f.listFiles(new GenFileFilter(start, extension));
    String n;
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++) {
        n = reduceFileName(f.getPath() + "\\" + list[i].getName());
        result.add(n);
      }
    return result;
  }
 
  // Compression du dossier directory dans directory.zip
  public static void zip(String directory) {
    System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
    System.out.println("Archiving directory " + directory + " in file " + directory + ".zip :");
    try {
      FileOutputStream fos = new FileOutputStream(directory + ".zip");
      ZipOutputStream zos = new ZipOutputStream(fos);
      Vector entries = getFileList(directory, "*");
      int n = entries.size();
      String s;
      String s2;
      ZipEntry ze;
      RandomAccessFile raf = null;
      byte[] bb;
      int l = directory.length() + 1;
      for (int i = 0 ; i < n ; i++) {
        s = (String)entries.get(i);
//        System.out.print(" " + s.substring(Math.max(0, s.length() - 20), s.length()));
        s2 = s.substring(l);
        raf = new RandomAccessFile(s, "r");
        bb = new byte[(int)raf.length()];
        raf.read(bb);
        ze = new ZipEntry(s2);
        zos.putNextEntry(ze);
        zos.write(bb);
        raf.close();
        printPercent(i, n);
      }
      zos.finish();
      System.out.println("\nArchiving done. Thank you for using me!");
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  // Dézippe une archive archive.zip dans le dossier archive
  public static void unzip(String file) {
    try {
      String directory = file.substring(0, file.lastIndexOf(".")) + "/";
      System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
      System.out.println("Extracting file " + file + " in directory " + directory + " :");
      ZipFile zf = new ZipFile(file);
      ZipEntry ze;
      Hashtable ht = new Hashtable();
      int nf = 0;
      Enumeration e = zf.entries();
      for ( ; e.hasMoreElements() ; ) {
        ze = (ZipEntry)e.nextElement();
        ht.put(ze.getName(), ze);
        nf++;
      }
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      byte[] bb = new byte[(int)raf.length()];
      raf.read(bb);
      raf.close();
      ByteArrayInputStream bais = new ByteArrayInputStream(bb);
      ZipInputStream zis = new ZipInputStream(bais);
      ze = zis.getNextEntry();
      String s;
      int i;
      int n;
      int l;
      int n2 = 0;
      while (ze != null) {
        ze = (ZipEntry)ht.get(ze.getName());
        s = directory + ze.getName();
        bb = new byte[(int)ze.getSize()];
        i = 0;
        l = bb.length;
        while (l > 0) {
          n = zis.read(bb, i, l);
          i += n;
          l -= n;
        }
        createFile(s);
        raf = new RandomAccessFile(s, "rw");
        raf.write(bb);
        raf.close();
        ze = zis.getNextEntry();
        printPercent(n2, nf);
        n2++;
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("\nExtracting done. Thank you for using me!");
  }
 
  // Simplifie un nom de fichier
  public static String reduceFileName(String s) {
    String s2 = s.replace('\\', '/');
    String[] words = s2.split("/");
    boolean[] ok = new boolean[words.length];
    for (int i = 0 ; i < words.length ; i++) 
      ok[i] = true;
    for (int i = words.length - 1 ; i >= 0 ; i--) {
      if (words[i].equals("..")) {
        int j = i - 1;
        while ((j >= 0) && ((words[j].equals("..")) || (!ok[j])))
          j--;
        if (j >= 0) {
          ok[i] = false;
          ok[j] = false;
        }
      }
    }
    s2 = "";
    for (int i = 0 ; i < words.length - 1 ; i++)
      if (ok[i])
        s2 += words[i] + "/";
    return s2 + words[words.length - 1];
  }
 
  // Crée un fichier et son chemin d'accès
  public static void createFile(String fileName) {
    if (fileName.indexOf('/') > 0) {
      File f = new File(fileName.substring(0, fileName.lastIndexOf('/')));
      f.mkdirs();
    }
    File f = new File(fileName);
    try {
      FileWriter fw = new FileWriter(fileName, false);
      fw.close();
    }
    catch (Exception e) {
    }
  }
 
  // Affiche un message de progression
  public static void printPercent(float step, float stepsCount) {
    float step_1 = step + 1;
    int percent = Math.round(step_1 * 100 / stepsCount);
    if (percent >= 100)
      percent = 99;
    String message = "" + percent + "%";
    if (percent < 10)
      message = " " + message; 
    if (step_1 >= stepsCount)
      message = "job done, " + (int)stepsCount + " steps.                                                     \n";
    else
      message = message + " - " + getHour() + " - step " + (int)(step_1) + "/" + (int)stepsCount;
    System.out.print("\r");
    if (step == 0)
      System.out.println("  " + getHour() + "  Starting job.");
    if (step_1 >= stepsCount)
      System.out.print("  " + getHour());
    System.out.print("  Working : " + message);
  }
 
  // Affiche l'heure
  public static String getHour() {
    return new SimpleDateFormat("HH:mm:ss").format(new Date());
  }
 
  // Efface l'arborescence des dossiers dans directory
  private static void deleteDirectory(String directory) {
    File f;
    Vector v = getDirectoryList(directory);
    int n = v.size();
    for (int i = 0 ; i < n ; i++)
      deleteDirectory(directory + "/" + (String)v.get(i));
    f = new File(directory);
    f.delete();
  }
 
  // Classe filtre pour fichiers
  private static class GenFileFilter implements FileFilter {
 
    private String start;
    private String extension;
    private boolean allFiles;
    private boolean allExts;
 
    public GenFileFilter(String ext) {
      start = "";
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts;
    }
 
    public GenFileFilter(String s, String ext) {
      start = new String(s);
      start = start.toLowerCase();
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts && start.equals("*");
    }
 
    public boolean accept(java.io.File file) {
      if (!file.isFile())
        return false;
      if (allFiles)
        return true;
 
 
 
      String n = file.getName();
      if (n.length() < start.length())
        return false;
      n = n.toLowerCase();
      String tst = n.substring(0, start.length());
      if (!tst.equals(start))
        return false;
      if (allExts)
        return true;
      if (n.lastIndexOf(".") < 0)
        return false;
      tst = n.substring(n.lastIndexOf(".") + 1, n.length());
      return tst.equals(extension);
    }
 
  }
 
  // Classe filtre pour répertoires
  private static class DirFileFilter implements FileFilter {
 
    public DirFileFilter() {
    }
 
    public boolean accept(java.io.File file) {
      return file.isDirectory();
    }
 
  }
 
}

L'accessoire de nettoyage de disque fait référence à la discussion suivante :
commande format et nettoyage disque dur

millie · 26/01/2009, 13h26

Salut,

Tu ne veux pas plutôt dire que c'est un explorateur ?

sinok · 26/01/2009, 13h38

Faudrait peut être éviter de localiser la classe sous windows, (par exemple pour la création du fichier temporaire).

Peut être propager les exceptions également.

anadoncamille · 26/01/2009, 17h04

Citation:

Envoyé par millie

Tu ne veux pas plutôt dire que c'est un explorateur ?

Cela me ferait grand plaisir de l'appeler explorateur mais il n'en a que les fonctionnalités et aucune interface. En tout cas moyennant une interface, pour sûr il peut servir un explorateur.
Je l'ai appelé Mini OS en souvenir de ce bon vieux DOS.
Dans mon projet cette classe s'appelle KOS (K1000 OS).

Pour la localisation sous windows, cette localisation ne concerne que le nettoyeur de disque et est proposée en exemple d'utilisation. C'est facilement transposable en Linux ou Mac. Le reste des méthodes est non localisé. Pour la propagation des exceptions, je l'évite pour créer des méthodes tendant vers la gestion autonome, c'est à dire que dans la mesure du possible je traite les exceptions dans la méthode elle-même. C'est très rare que je propage les exceptions, mais c'est un choix de programmation parfaitement discutable.

Je vous donne Mini-OS telle que je l'utilise. Vous pouvez la modifier et l'améliorer pour qu'elle soit plus adaptée à vos besoins.

kamilia_85 · 31/01/2009, 14h42

Citation:

Envoyé par anadoncamille

Bonjour,

voici une des classes dont j'utilise le plus souvent les services dans mes projets. C'est un Mini-OS regroupant des services bien utiles :

- recherche de fichiers
- copie et création de fichiers
- effacement de fichiers
- deltree
- nettoyage de disque
- zip
- unzip

Le voici, il n'est pas très commenté mais très fonctionnel et disponible :

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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
 
import java.io.*;
import java.util.*;
import java.text.*;
import java.util.zip.*;
 
public class MiniOS {
 
  // nettoie les disques c, d, e et f
  public static void main(String[] args) {
    String f0 = "monFichier.mp3"; // Un gros fichier (2 - 10 Mo)
    String f1 = "monFichier.jpg"; // Un fichier moyen (20 - 100 Ko)
    String f2 = "monFichier.txt"; // Un petit fichier (1 octet)
    cleanEmptySpaces("c", false, f0, f1, f2); // Remplit c:
    cleanEmptySpaces("d", false, f0, f1, f2); // Remplit d:
    cleanEmptySpaces("e", false, f0, f1, f2); // Remplit e:
    cleanEmptySpaces("f", false, f0, f1, f2); // Remplit f:
    delTree("c:\temp"); // Libère c:
    delTree("d:\temp"); // Libère d:
    delTree("e:\temp"); // Libère e:
    delTree("f:\temp"); // Libère f:
  }
 
  // nettoie un disque, si solo=true le répertoire temp est supprimé directement, 
  // sinon l'algorithme est plus efficace avec plusieurs lecteurs en faisant 
  // les effacements en groupé à la fin
  public static void cleanEmptySpaces(String diskLetter, boolean solo, String f0, String f1, String f2) {
    System.out.println("\nRC Pro __oPRo__ :\n=================\n\nScan de " + diskLetter + ":");
    String d = diskLetter + ":/temp";
    System.out.print("Ecrasemment :  ");
    String[] cs = {"\\", "|", "/", "-"};
    int i = 0;
    while (writeTempFile(f0, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f1, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    while (writeTempFile(f2, diskLetter)) {
      i++;
      System.out.print("\b" + cs[i % 4]);
    }
    System.out.println("\baplani.");
    if (solo)
      delTree(d);
  }
 
  // Copie un fichier dans le répertoire temp
  public static boolean writeTempFile(String sourceFile, String diskLetter) {
    return copyFile(sourceFile, diskLetter + ":/temp/FNEC_" + System.currentTimeMillis() + ".tmp", false);
  }
 
  // Copie un fichier src dans dst
  public static boolean copyFile(String src, String dst) {
    return copyFile(src, dst, true);
  }
 
  // Copie un fichier src dans dst, renvoie false si la copie a échoué
  public static boolean copyFile(String src, String dst, boolean verbose) {
    try {
      RandomAccessFile raf = new RandomAccessFile(src, "r");
      int n = (int)raf.length();
      byte[] data = new byte[n];
      raf.readFully(data);
      raf.close();
      createFile(dst);
      raf = new RandomAccessFile(dst, "rw");
      raf.setLength(0);
      raf.write(data);
      raf.close();
    }
    catch (Exception e) {
	  if (verbose)
        e.printStackTrace();
	  return false;
    }
	return true;
  }
 
  // Copie de src dans dst les fichiers *.*
  public static void copyDirectory(String src, String dst) {
    System.out.println("Copying tree " + src + " in " + dst);
    copyDirectory(src, dst, "*");
  }
 
  // Copie de src dans dst les fichiers *.extension
  public static void copyDirectory(String src, String dst, String ext) {
    copyDirectory(src, dst, "", ext);
  }
 
  // Copie de src dans dst les fichiers start*.extension
  public static void copyDirectory(String src, String dst, String start, String ext) {
    Vector v = getFileList(src, start, ext);
    int n = v.size();
    String s;
    String d;
    for (int i = 0 ; i < n ; i++) {
      s = (String)v.get(i);
      d = dst + s.substring(src.length());
      copyFile(s, d);
      printPercent(i, n);
    }
  }
 
  // Efface directory et son contenu
  public static void delTree(String directory) {
    System.out.println("Deleting tree " + directory);
    deleteFiles(directory, "*");
    deleteDirectory(directory);
  }
 
  // Efface *.* dans directory
  public static void deleteFiles(String directory) {
    deleteFiles(directory, "*");
  }
 
  // Efface *.extension dans directory
  public static void deleteFiles(String directory, String extension) {
    deleteFiles(directory, "", extension);
  }
 
  // Efface start*.extension dans directory
  public static void deleteFiles(String directory, String start, String extension) {
    System.out.println("Deleting " + directory + "/" + start + "*." + extension);
    File f;
    Vector v = getFileList(directory, start, extension);
    int n = v.size();
    for (int i = 0 ; i < n ; i++) {
      f = new File((String)v.get(i));
      f.delete();
      printPercent(i, n);
    }
  }
 
  // Efface un fichier
  public static void deleteFile(String s) {
    System.out.println("Deleting " + s);
    File f = new File(s);
    f.delete();
  }
 
  // Renvoie la liste des dossiers dans directory
  public static Vector getDirectoryList(String directory) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.add(list[i].getName());
    return result;
  }
 
  // Renvoie la liste de *.extension dans directory
  public static Vector getFileList(String directory, String extension) {
    return getFileList(directory, "", extension);
  }
 
  // Renvoie la liste de start*.extension dans directory
  public static Vector getFileList(String directory, String start, String extension) {
    Vector result = new Vector();
    File f = new File(directory);
    File[] list = f.listFiles(new DirFileFilter());
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++)
        result.addAll(getFileList(f.getPath() + "\\" + list[i].getName(), extension));
    list = f.listFiles(new GenFileFilter(start, extension));
    String n;
    if ((list != null) && (list.length != 0))
      for (int i = 0 ; i < list.length ; i++) {
        n = reduceFileName(f.getPath() + "\\" + list[i].getName());
        result.add(n);
      }
    return result;
  }
 
  // Compression du dossier directory dans directory.zip
  public static void zip(String directory) {
    System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
    System.out.println("Archiving directory " + directory + " in file " + directory + ".zip :");
    try {
      FileOutputStream fos = new FileOutputStream(directory + ".zip");
      ZipOutputStream zos = new ZipOutputStream(fos);
      Vector entries = getFileList(directory, "*");
      int n = entries.size();
      String s;
      String s2;
      ZipEntry ze;
      RandomAccessFile raf = null;
      byte[] bb;
      int l = directory.length() + 1;
      for (int i = 0 ; i < n ; i++) {
        s = (String)entries.get(i);
//        System.out.print(" " + s.substring(Math.max(0, s.length() - 20), s.length()));
        s2 = s.substring(l);
        raf = new RandomAccessFile(s, "r");
        bb = new byte[(int)raf.length()];
        raf.read(bb);
        ze = new ZipEntry(s2);
        zos.putNextEntry(ze);
        zos.write(bb);
        raf.close();
        printPercent(i, n);
      }
      zos.finish();
      System.out.println("\nArchiving done. Thank you for using me!");
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  // Dézippe une archive archive.zip dans le dossier archive
  public static void unzip(String file) {
    try {
      String directory = file.substring(0, file.lastIndexOf(".")) + "/";
      System.out.println("(c) 2009 Sylvain Tournois - www.anadoncamille.com");
      System.out.println("Extracting file " + file + " in directory " + directory + " :");
      ZipFile zf = new ZipFile(file);
      ZipEntry ze;
      Hashtable ht = new Hashtable();
      int nf = 0;
      Enumeration e = zf.entries();
      for ( ; e.hasMoreElements() ; ) {
        ze = (ZipEntry)e.nextElement();
        ht.put(ze.getName(), ze);
        nf++;
      }
      RandomAccessFile raf = new RandomAccessFile(file, "r");
      byte[] bb = new byte[(int)raf.length()];
      raf.read(bb);
      raf.close();
      ByteArrayInputStream bais = new ByteArrayInputStream(bb);
      ZipInputStream zis = new ZipInputStream(bais);
      ze = zis.getNextEntry();
      String s;
      int i;
      int n;
      int l;
      int n2 = 0;
      while (ze != null) {
        ze = (ZipEntry)ht.get(ze.getName());
        s = directory + ze.getName();
        bb = new byte[(int)ze.getSize()];
        i = 0;
        l = bb.length;
        while (l > 0) {
          n = zis.read(bb, i, l);
          i += n;
          l -= n;
        }
        createFile(s);
        raf = new RandomAccessFile(s, "rw");
        raf.write(bb);
        raf.close();
        ze = zis.getNextEntry();
        printPercent(n2, nf);
        n2++;
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    System.out.println("\nExtracting done. Thank you for using me!");
  }
 
  // Simplifie un nom de fichier
  public static String reduceFileName(String s) {
    String s2 = s.replace('\\', '/');
    String[] words = s2.split("/");
    boolean[] ok = new boolean[words.length];
    for (int i = 0 ; i < words.length ; i++) 
      ok[i] = true;
    for (int i = words.length - 1 ; i >= 0 ; i--) {
      if (words[i].equals("..")) {
        int j = i - 1;
        while ((j >= 0) && ((words[j].equals("..")) || (!ok[j])))
          j--;
        if (j >= 0) {
          ok[i] = false;
          ok[j] = false;
        }
      }
    }
    s2 = "";
    for (int i = 0 ; i < words.length - 1 ; i++)
      if (ok[i])
        s2 += words[i] + "/";
    return s2 + words[words.length - 1];
  }
 
  // Crée un fichier et son chemin d'accès
  public static void createFile(String fileName) {
    if (fileName.indexOf('/') > 0) {
      File f = new File(fileName.substring(0, fileName.lastIndexOf('/')));
      f.mkdirs();
    }
    File f = new File(fileName);
    try {
      FileWriter fw = new FileWriter(fileName, false);
      fw.close();
    }
    catch (Exception e) {
    }
  }
 
  // Affiche un message de progression
  public static void printPercent(float step, float stepsCount) {
    float step_1 = step + 1;
    int percent = Math.round(step_1 * 100 / stepsCount);
    if (percent >= 100)
      percent = 99;
    String message = "" + percent + "%";
    if (percent < 10)
      message = " " + message; 
    if (step_1 >= stepsCount)
      message = "job done, " + (int)stepsCount + " steps.                                                     \n";
    else
      message = message + " - " + getHour() + " - step " + (int)(step_1) + "/" + (int)stepsCount;
    System.out.print("\r");
    if (step == 0)
      System.out.println("  " + getHour() + "  Starting job.");
    if (step_1 >= stepsCount)
      System.out.print("  " + getHour());
    System.out.print("  Working : " + message);
  }
 
  // Affiche l'heure
  public static String getHour() {
    return new SimpleDateFormat("HH:mm:ss").format(new Date());
  }
 
  // Efface l'arborescence des dossiers dans directory
  private static void deleteDirectory(String directory) {
    File f;
    Vector v = getDirectoryList(directory);
    int n = v.size();
    for (int i = 0 ; i < n ; i++)
      deleteDirectory(directory + "/" + (String)v.get(i));
    f = new File(directory);
    f.delete();
  }
 
  // Classe filtre pour fichiers
  private static class GenFileFilter implements FileFilter {
 
    private String start;
    private String extension;
    private boolean allFiles;
    private boolean allExts;
 
    public GenFileFilter(String ext) {
      start = "";
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts;
    }
 
    public GenFileFilter(String s, String ext) {
      start = new String(s);
      start = start.toLowerCase();
      extension = new String(ext);
      extension = extension.toLowerCase();
      allExts = extension.equals("*");
      allFiles = allExts && start.equals("*");
    }
 
    public boolean accept(java.io.File file) {
      if (!file.isFile())
        return false;
      if (allFiles)
        return true;
 
 
 
      String n = file.getName();
      if (n.length() < start.length())
        return false;
      n = n.toLowerCase();
      String tst = n.substring(0, start.length());
      if (!tst.equals(start))
        return false;
      if (allExts)
        return true;
      if (n.lastIndexOf(".") < 0)
        return false;
      tst = n.substring(n.lastIndexOf(".") + 1, n.length());
      return tst.equals(extension);
    }
 
  }
 
  // Classe filtre pour répertoires
  private static class DirFileFilter implements FileFilter {
 
    public DirFileFilter() {
    }
 
    public boolean accept(java.io.File file) {
      return file.isDirectory();
    }
 
  }
 
}

L'accessoire de nettoyage de disque fait référence à la discussion suivante :
commande format et nettoyage disque dur

vous avez utilisez monfichier.txt de 1 octet cad un fichier mais pour le cas de un dossier qui contient de plus de 1000 fichier .txt j'arrive pas a le ouvrir ,par la méthode ouvrire suivanteje peut ouvrir un seule fichier.txt :

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
void ouvrir(){
          String path = new String("");
jFileChooser jFileChooser1 = new jFileChooser();
 
 
 
           if (JFileChooser.APPROVE_OPTION == jFileChooser1.showOpenDialog(this)) {
               path = jFileChooser1.getSelectedFile().getPath();
           }
           try {this.setTitle("ouvrir une Corpus de text -"+path);
               File file = new File(path);
               int size = (int) file.length();
               int chars_read = 0;
               FileReader in = new FileReader(file);
               char[] data = new char[size];
               while (in.ready()) {
                   chars_read += in.read(data, chars_read, size - chars_read);
               }
               in.close();
               aaaa = new String(data, 0, chars_read);
               jTextArea5.append(aaaa);
               } catch (IOException E) {
           }
 
     }

si vous pouvez me proposé une nouvelle idé ou une petite amélioration je serais trés ravis

anadoncamille · 02/02/2009, 00h29

Bonjour kamilia_85,

Pour ouvrir et lire un fichier texte, vous pouvez utiliser la classe sur le lien suivant : Lecteur de fichiers textes.
Cette classe vous permettra de lire tous les fichiers de votre dossier, quel que soit leur nombre.

Le code swing que vous utilisez permet de sélectionner les fichiers à ouvrir un par un. Si vous voulez ouvrir plusieurs fichiers en même temps, vous devez utiliser un algorithme de recherche fonctionnant comme la commande DOS

Code :

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

dir *.txt

et vous pourrez utiliser les méthodes de recherche de fichier du Mini-OS pour déterminer la liste des fichiers à ouvrir.

Code :

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

1
2
3
4
5
6
7
8
 
Vector listeFichiers = MiniOS.getFileList("monDossier", "txt");
String fichier;
for (int n = 0 ; i < listeFichiers.size() ; i++) {
  fichier = (String)v.get(i);
  ...
  votre code ;
}

Votre fenêtre de choix de fichier pourra vous servir à décider quels fichiers vous voulez lire (*.txt, *.doc, etc...)

17/10/2008, 00h14	#91
®om Expert Confirmé Inscription : janvier 2005 Messages : 2 807 Détails du profil Informations forums : Inscription : janvier 2005 Messages : 2 807 Points : 2 821 Points : 2 821	Merci adiGuba, j'ai eu la flemme __________________ ®om's blog http://rom.developpez.com Piratage ou usage commun ? Comprendre le mystère de l'argent et le problème des intérêts manquants
	00

26/01/2009, 13h26	#96
millie Rédacteur/Modérateur Inscription : juin 2006 Messages : 6 935 Détails du profil Informations personnelles : Localisation : Luxembourg Informations forums : Inscription : juin 2006 Messages : 6 935 Points : 9 062 Points : 9 062	Salut, Tu ne veux pas plutôt dire que c'est un explorateur ? __________________ Je ne répondrai à aucune question technique en privé
	00

26/01/2009, 13h38	#97
sinok Modérateur Inscription : août 2004 Messages : 8 640 Détails du profil Informations personnelles : Âge : 33 Localisation : France, Paris (Île de France) Informations forums : Inscription : août 2004 Messages : 8 640 Points : 12 444 Points : 12 444	Faudrait peut être éviter de localiser la classe sous windows, (par exemple pour la création du fichier temporaire). Peut être propager les exceptions également. __________________ Hey, this is mine. That's mine. All this is mine. I'm claiming all this as mine. Except that bit. I don't want that bit. But all the rest of this is mine. Hey, this has been a really good day. I've eaten five times, I've slept six times, and I've made a lot of things mine. Tomorrow, I'm gonna see if I can't have sex with something.
	00

Outils de la discussion
Afficher une version imprimable Envoyer un lien vers cette page par email