Bonjour,
 
Voila j'ai une JProgressBar (dans un JPanel d'un JFrame) pour lire un fichier d'un serveur distant. Mais ma JProgressBar m'affiche 100% dessuite
Pour la lecture du fichier j'utilise un getInputStream.
J'ai l'impression qu'il faut utiliser 2 threads l'un pour afficher la JProgressBar et l'autre pour rappatrier le fichier mais je ne saisi pas la notion sous jacente
 

public void setValeur(int compteur){
        
        System.out.println(compteur+" | "+this.jpbmax);
        
        this.jpb.setValue(compteur);
        this.jpb.setString(compteur * 100 / this.jpbmax +"%" );
        this.jpbCdr.paintComponents(this.jpbCdr.getGraphics());
        
        try { Thread.sleep(1000);} 
        catch(Exception e) {}
    }

public void downloadFile() { 
        URLConnection connection = null;
        InputStream is = null;
        FileOutputStream destinationFile = null;
        String pathfile = this.tabXml[ this.indexMaj ][2] + "/" + this.tabXml[ this.indexMaj ][3];
        
        try {
            //On crée l'URL
            URL url = new URL( pathfile );
 
            //On crée une connection vers cet URL
            connection = url.openConnection( );
 
            //On récupère la taille du fichier
            this.jpbmax = connection.getContentLength();
 
            //Si le fichier est inexistant, on lance une exception
            if(this.jpbmax == -1){
                throw new IOException("Fichier vide" );
            }
 
            //On récupère le stream du fichier
            is = new BufferedInputStream(connection.getInputStream());
 
            //On prépare le tableau de bits pour les données du fichier
            byte[] data = new byte[ this.jpbmax ];
 
            //On déclare les variables pour se retrouver dans la lecture du fichier
            int currentBit = 0;
            int deplacement = 0;
            
            //Tant que l'on n'est pas à la fin du fichier, on récupère des données
            while(deplacement < this.jpbmax){
                currentBit = is.read(data, deplacement, data.length-deplacement);    
                if(currentBit == -1) break;
                deplacement += currentBit;
                setValeur(deplacement);
            }
 
            //Si on n'est pas arrivé à la fin du fichier, on lance une exception
            if(deplacement != this.jpbmax) throw new IOException("Le fichier n'a pas été lu en entier (seulement " + deplacement + " sur " + this.jpbmax + " )" );
                    
            //On crée un stream sortant vers la destination
            destinationFile = new FileOutputStream( "tmp.jar" );
 
            //On écrit les données du fichier dans ce stream
            destinationFile.write(data);
 
            //On vide le tampon et on ferme le stream
            destinationFile.flush();
 
        } catch (MalformedURLException e) { System.err.println("Problème avec l'URL : " + pathfile); }
        catch (IOException e) { e.printStackTrace(); }
        finally {
            try {
                is.close();
                destinationFile.close();
                
                
                
            } catch (IOException e) { e.printStackTrace(); }
        }
    }

 
 
Please  

C'est ici que tu devrais utiliser invokeLater()
 
Bon alors... d'abord ta JProgressbar tu dois lui spécifier un minimum et un maximum. Par défaut ça va de 0 à 100. Toi tu dois spécifier que le maximum est la valeur this.jpbmax.
 
Ensuite, si ta méthode downloadFile() est démarrée dans le thread graphique (en réponse à un clic sur un bouton, un événement clavier ou autres), tu dois changer ça. Il faut que la méthode downloadFile() soit lancée dans un nouveau Thread sinon l'interface graphique va se "figer" pendant toute la durée du download et se débloquer à la fin. Raison pour laquelle tu passes de 0 à 100% en une étape.
 
Troisièmement, tu dois exécuter le code de la méthode setValeur() avec SwingUtilities.invokeLater(). Il s'agit en effet du code qui met à jour l'interface graphique donc il doit s'exécuter dans le thread graphique et invokeLater te permet de lancer des actions dans le thread graphique (puisqu'on est dans le thread qui download).
 
Enfin, tu devrais écrire directement le fichier sur le disque sans le stocker entièrement en mémoire! Surtout si ton fichier fait plusieurs dizaines ou centaines de MégaOctets. Tu dois juste allouer un buffer (je dirais de 16, 32 ou éventuellement 64 KiloOctets) et transférer les données de l'inputstream vers l'outputstream au fur et à mesure qu'elles arrivent, via ce même buffer. Bien sûr, si tu vois que jpbmax est plus petit que la taille de ton buffer, alors alloue un buffer de taille jpbmax pour ne pas gaspiller de mémoire.

hihihi tu es un vrai noctambule
Bon je vais me renseigner sur les threads et invokeLater car j'ai des carences a combler après je pense que je comprendrais mieux
 
Merci de tes infos que je garde sous le coude.
 
concernant la jprogressbar je l'initialise correctement :
 

public void jpb(JFrame jf){
        this.jpbCdr = new JFrame("En cours de téléchargement..." );
                
        JPanel panneau = new JPanel();
        
        this.jpb = new JProgressBar(0, this.jpbmax);
        this.jpb.setStringPainted(true);
        this.jpb.setValue(0);
        this.jpb.setString("0%" );
        
        panneau.add("Center", this.jpb);
        panneau.add("Center", new JLabel("Version " + newVersion()));
        
        this.jpbCdr.getContentPane().add(BorderLayout.CENTER, panneau);
        this.jpbCdr.setSize(275,85);
        this.jpbCdr.setLocation(
                jf.getX() + (jf.getWidth()-this.jpbCdr.getWidth())/2,
                jf.getY() + (jf.getHeight()-this.jpbCdr.getHeight())/2
        ); 
        this.jpbCdr.setResizable(false);
        this.jpbCdr.setVisible(true);
    }

 
et pour le fichier il ne sera pas gros donc je peux le stocker en mémoire pour le moment ! mais en effet ta remarque est juste

Si le fichier n'est pas gros... quelle est l'intérêt d'une progressBar?

l'intérêt est juste de savoir me servir de la jprogressbar. Je débute en Java et donc j'étudie tout ce qui me parait interessant. Dans ce cas la ca me fait aborder les notions de threads notament
 
Donc concernant la JProgressBar ce que je ne comprend pas c'est que un thread est demarré par la méthode start et l'OS a un moment donné va donner du temps processeur a ce thread et executer la methode run() de la classe fille. Mais quand je veux 2 thread qui executent 2 fonctions différentes mais néanmoins liées (l'un est l'affichage graphique et l'autre le download du fichier) je dois obligatoirement faire 2 classes dans 2 fichiers différents ? je trouve cela lourd  
Tous les tutoriaux que je trouve les 2 thread partage la meme methode run et il partage une variable membre de cette classe. Ce qui n'est pas mon cas. Peux tu me confirmer ?

Tu ne dois pas faire 2 classes bien au contraire, tu peux déclarer ta classe Runnable et y implémenter une méthode run() ou bien définir un Thread/Runnable directement dans le code:
 

new Thread() {
   public void run() {
      Runnable guiUpdater = new Runnable() {
         public void run() {
            // code qui met à jour l'affichage de la progressBar
         }
      };
      // boucle de téléchargement
      for(...) {
         ...
         SwingUtilities.invokeLater(guiUpdater);
      }
   }
}.start();

 
Le code ci-dessus définit et démarre un nouveau Thread. Il n'est pas nécessaire d'en garder une référence sauf si tu veux pouvoir appeler interrupt() dessus plus tard.
 
Ici les 2 threads partagent une variable aussi: c'est le nombre de bytes actuellement lus. Ce nombre est mis à jour par le thread qui download et il est aussi utilisé par le thread graphique pour calculer ce que la progressBar doit afficher.

Super !!
Je commence à comprendre la notion de thread et l'interface runnable ! (enfin c'est tellement plus facile avec la solution   )
Ya aussi la classe abstraite SwingWorker que l'on peut utiliser.
 
PS : tu fais comment pour que ton texte dans la balise code apparaisse avec des couleurs ?  

Oui là je le fais à la "mano" mais effectivement SwingWorker peut simplifier la tâche en exécutant des méthodes dédiées que tu redéfinis dans des threads différents. C'est une classe d'aide, nouveauté de Java 1.6. L'idéal est de lire la documentation de la classe, tout est expliqué. Dans ton cas, la méthode doInBackground() serait celle qui effectue le téléchargement. La méthode process() est appelée tout à la fin du téléchargement dans le thread graphique et reçoit le résultat.
 
Quoique je ne trouve pas que le code soit tellement simplifié avec SwingWorker puisque tu devrais créer également un "PropertyChangeListener" qui serait notifié à chaque étape du téléchargement afin de mettre à jour la progressBar. Cela fait beaucoup de tuyauterie.
 
Pour utiliser la coloration syntaxique du code java j'utilise les balises BBCode (code==java)(/code) où les parenthèses doivent être remplacées par des [].

Bon je me rends compte que je ne comprends pas tout   . Ya encore des choses qui m'échappe. Je vais devoir bosser dessus
 
Je réflechis en séquentiel et pas en évenementiel. J'ai pas mal de mal    
 
Merci pour le bbcode, ca apparait niquel  

Ah c'est sûr que les interfaces graphiques, c'est de l'événementiel à 100%! C'est ce qu'on doit apprendre en dernier après tout le reste. Et puis il y a aussi des gens qui ne comprennent jamais la notion de Thread, un peu comme ceux qui ne parviennent pas à comprendre la notion de récursivité.

J'ai eu du mal avec la récursivité quand on m'a invité à mon taf à en faire pour un forum. Mais ensuite une fois qu'on comprends l'empilement et le dépilement ca roule    
Pareil ici je pense, j'ai encore un peu de mal, mais le vocabulaire et les notions théoriques commencent à rentrer après je pense que je vais "voir" le code beaucoup plus facilement

Une petite question :
 
 

new Thread() {
   public void run() {
      Runnable guiUpdater = new Runnable() {
         public void run() {
            // code qui met à jour l'affichage de la progressBar
         }
      };
      
    uneMethode(guiUpdater);
 
   }
}.start();
 
uneMethode(Runnable guiUpdater){
 
SwingUtilities.invokeLater(guiUpdater);
}

 
J'ai découpé dans une méthode le téléchargement. Comment je peux passer la référence de guiUpdater au lieu d'avoir une copie locale dans la méthode "uneMethode" ?

Bon apparemment tous les objets sont passés par référence  

Bon j'ai réduit le code et cela marche très bien
Dans downloadfile, j'appelle directement ma méthode qui met à jour la JProgressBar.
 
[code==java]public void traitement(){
  new Thread() {
   public void run() {
    downloadFile();
   }
  }.start();
 }[/java]
 
Quel était l'intérêt de ta méthode ?   Doit on absolument implementer la classe runnable pour la mise à jour graphique ? pourquoi ne pas laisser le nouveau thread gérer cela ?
 
Hum, j'ai changé le fichier qui est téléchargé par un fichier de 4Mo (au lieu de 20Ko) est ce pour cela que maintenant je n'ai pas le saut à 100% directement ?
 
   
 

En java les objets sont tous passés par référence et les types primitifs (int, long, float, double, boolean) sont tous passés par valeur.
 
Les instructions qui modifient l'interface graphique doivent être exécutées dans le thread de Swing. je ne dis pas ça pour t'emmerder, c'est écrit dans la documentation. Maintenant peut-être que dans ton cas ça fonctionne pour une raison ou une autre mais ce n'est pas la bonne façon de faire.
 
Et oui on est obligé de passer par une classe qui implémente Runnable en Java car il n'existe pas de pointeurs vers des fonctions dans ce langage.