Publicité
Discussion fermée Actualité déjà publiée
Page 5 sur 6 PremièrePremière 123456 DernièreDernière
Affichage des résultats 81 à 100 sur 110
  1. #81
    Membre à l'essai
    Inscrit en
    avril 2008
    Messages
    18
    Détails du profil
    Informations forums :
    Inscription : avril 2008
    Messages : 18
    Points : 20
    Points
    20

    Par défaut Webstart like

    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
    Fichiers attachés Fichiers attachés
      0  0

  2. #82
    Membre confirmé Avatar de Philcmoi
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    392
    Détails du profil
    Informations personnelles :
    Âge : 43
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : juillet 2006
    Messages : 392
    Points : 276
    Points
    276

    Par défaut comment transformer une date facon anglaise en francaise

    il suffit de faire :
    Code :
    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
      0  0

  3. #83
    Membre confirmé Avatar de Philcmoi
    Profil pro
    Inscrit en
    juillet 2006
    Messages
    392
    Détails du profil
    Informations personnelles :
    Âge : 43
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : juillet 2006
    Messages : 392
    Points : 276
    Points
    276

    Par défaut Comment vérifier qu'une adresse email exite par confirmation d'un message

    Ce code utilise l'api java mail 1.3.
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    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 :
    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 :
    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.
      0  0

  4. #84
    Rédacteur/Modérateur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 945
    Détails du profil
    Informations personnelles :
    Localisation : Luxembourg

    Informations forums :
    Inscription : juin 2006
    Messages : 6 945
    Points : 9 779
    Points
    9 779

    Par défaut

    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 :
    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");
     
    	}
     
    }
    Je ne répondrai à aucune question technique en privé
      0  0

  5. #85
    Membre confirmé Avatar de Razgriz
    Chercheur en informatique
    Inscrit en
    avril 2006
    Messages
    383
    Détails du profil
    Informations professionnelles :
    Activité : Chercheur en informatique

    Informations forums :
    Inscription : avril 2006
    Messages : 383
    Points : 259
    Points
    259

    Par défaut

    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 :
    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;
        }
    }
    On a toujours besoin d'un plus bourrin que soi

    Oui il y a quelques bugs dans ma librairie de Sécurité, mais les classes postées ne sont pas celles de la dernière version, et j'ai la flemme de tout modifier. Je vous donnerai avec plaisir la dernière version du jar par mp.
      0  0

  6. #86
    Rédacteur/Modérateur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 945
    Détails du profil
    Informations personnelles :
    Localisation : Luxembourg

    Informations forums :
    Inscription : juin 2006
    Messages : 6 945
    Points : 9 779
    Points
    9 779

    Par défaut

    Citation Envoyé par Razgriz Voir le message
    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 :
    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 :
    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
    Je ne répondrai à aucune question technique en privé
      0  0

  7. #87
    Membre émérite
    Avatar de kmdkaci
    Profil pro
    Inscrit en
    octobre 2007
    Messages
    559
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : octobre 2007
    Messages : 559
    Points : 901
    Points
    901

    Par défaut Calculatrice à opérations simples

    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 :
    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);
         }
     
      }
    Images attachées Images attachées
      0  0

  8. #88
    En attente de confirmation mail
    Inscrit en
    novembre 2005
    Messages
    19
    Détails du profil
    Informations forums :
    Inscription : novembre 2005
    Messages : 19
    Points : 25
    Points
    25

    Par défaut Méthode FillZéro

    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:
    Afficher 35 sur 6 caractères.

    On doit obtenir « 000035 ».

    Code :
    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
      0  0

  9. #89
    Expert Confirmé
    Avatar de ®om
    Inscrit en
    janvier 2005
    Messages
    2 812
    Détails du profil
    Informations forums :
    Inscription : janvier 2005
    Messages : 2 812
    Points : 3 091
    Points
    3 091

    Par défaut

    Citation Envoyé par ggorson Voir le message
    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 :
    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
      0  0

  10. #90
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 311
    Points : 21 539
    Points
    21 539

    Par défaut

    Citation Envoyé par ggorson Voir le message
    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 :
    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++
      0  0

  11. #91
    Expert Confirmé
    Avatar de ®om
    Inscrit en
    janvier 2005
    Messages
    2 812
    Détails du profil
    Informations forums :
    Inscription : janvier 2005
    Messages : 2 812
    Points : 3 091
    Points
    3 091

    Par défaut

    Merci adiGuba, j'ai eu la flemme
      0  0

  12. #92
    En attente de confirmation mail
    Inscrit en
    novembre 2005
    Messages
    19
    Détails du profil
    Informations forums :
    Inscription : novembre 2005
    Messages : 19
    Points : 25
    Points
    25

    Par défaut

    Citation Envoyé par adiGuba Voir le message
    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.
      0  0

  13. #93
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 311
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 311
    Points : 21 539
    Points
    21 539

    Par défaut

    Citation Envoyé par ggorson Voir le message
    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++
      0  0

  14. #94
    Membre habitué Avatar de anadoncamille
    Inscrit en
    juillet 2007
    Messages
    222
    Détails du profil
    Informations forums :
    Inscription : juillet 2007
    Messages : 222
    Points : 128
    Points
    128

    Par défaut JFrame plein écran

    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 :
    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 :
    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) {
      }
     
    }
    __________________________________
    | +
    | Sylvain Tournois - Création logicielle.
    |
    | http://www.anadoncamille.com/
    |
      0  0

  15. #95
    Membre habitué Avatar de anadoncamille
    Inscrit en
    juillet 2007
    Messages
    222
    Détails du profil
    Informations forums :
    Inscription : juillet 2007
    Messages : 222
    Points : 128
    Points
    128

    Par défaut Mini OS

    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 :
    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
    __________________________________
    | +
    | Sylvain Tournois - Création logicielle.
    |
    | http://www.anadoncamille.com/
    |
      0  0

  16. #96
    Rédacteur/Modérateur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 945
    Détails du profil
    Informations personnelles :
    Localisation : Luxembourg

    Informations forums :
    Inscription : juin 2006
    Messages : 6 945
    Points : 9 779
    Points
    9 779

    Par défaut

    Salut,

    Tu ne veux pas plutôt dire que c'est un explorateur ?
    Je ne répondrai à aucune question technique en privé
      0  0

  17. #97
    Modérateur
    Avatar de sinok
    Profil pro
    Inscrit en
    août 2004
    Messages
    8 762
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : août 2004
    Messages : 8 762
    Points : 12 849
    Points
    12 849

    Par défaut

    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.
      0  0

  18. #98
    Membre habitué Avatar de anadoncamille
    Inscrit en
    juillet 2007
    Messages
    222
    Détails du profil
    Informations forums :
    Inscription : juillet 2007
    Messages : 222
    Points : 128
    Points
    128

    Par défaut

    Citation Envoyé par millie Voir le message
    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.
    __________________________________
    | +
    | Sylvain Tournois - Création logicielle.
    |
    | http://www.anadoncamille.com/
    |
      0  0

  19. #99
    Invité régulier
    Inscrit en
    juin 2008
    Messages
    14
    Détails du profil
    Informations forums :
    Inscription : juin 2008
    Messages : 14
    Points : 6
    Points
    6

    Par défaut

    Citation Envoyé par anadoncamille Voir le message
    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 :
    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 :
    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
      0  0

  20. #100
    Membre habitué Avatar de anadoncamille
    Inscrit en
    juillet 2007
    Messages
    222
    Détails du profil
    Informations forums :
    Inscription : juillet 2007
    Messages : 222
    Points : 128
    Points
    128

    Par défaut Lecteur de fichiers texte

    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 et vous pourrez utiliser les méthodes de recherche de fichier du Mini-OS pour déterminer la liste des fichiers à ouvrir.

    Code :
    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...)
    __________________________________
    | +
    | Sylvain Tournois - Création logicielle.
    |
    | http://www.anadoncamille.com/
    |
      0  0

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •