在java中创建进度条以使用for循环的结果进行更新

我创建了一个从0到850000的for循环。我选择了一个较高的数字，因为我想创建一个进度条，该进度条将使用for循环中的结果进行更新。这是我目前掌握的代码

public class ProgressBarTest extends JFrame {

    private JPanel contentPane;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {





        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ProgressBarTest frame = new ProgressBarTest();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public ProgressBarTest() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);

        for(int i = 850000; i>0; i--) {
            System.out.println("i = " + i);
        }

    }

}

---

我似乎找不到一种方法来使用for循环更新进度条。我确实创建了一个在计时器上工作的进度条，但这不是我想要它做的。我基本上希望它从0%更新到100%。这对我来说似乎很简单，但我已经坚持了一段时间。我非常感谢任何能帮助我理解其工作原理的示例代码。

您需要使用SwingWorker，当Swing程序需要执行长时间运行的任务时，它通常使用一个工作线程。那么，试试这个：

public class JProgressBarTest extends SwingWorket<Void,Integer>{

private JProgressBar jpb;
  public ProgrssBarTest(JProgressBar jpb){
    this.jpb = jpb;
  }

  @Override
  protected void process(List<Integer> chunks){
    int i = chunks.get(chunks.size()-1);
    jpb.setValue(i);
  }

  @Override
  protected void doInBackground() throws Exception{
    int x = 0;
    for(int i = 850000; i>0; i--) {
        publish(x); //replace x with the number you want to increment the progressbar each time pubish is called
        x = x + i; //or replace i with the increment you want
        System.out.println("i = " + i);
    }
  }

  @Override
  protected void done(){
    try{
      get();
    }catch(ExecutionException |InterruptedException e){
      ;
    }
  }

}

---

您需要使用SwingWorker，当Swing程序需要执行长时间运行的任务时，它通常使用一个工作线程。那么，试试这个：

public class JProgressBarTest extends SwingWorket<Void,Integer>{

private JProgressBar jpb;
  public ProgrssBarTest(JProgressBar jpb){
    this.jpb = jpb;
  }

  @Override
  protected void process(List<Integer> chunks){
    int i = chunks.get(chunks.size()-1);
    jpb.setValue(i);
  }

  @Override
  protected void doInBackground() throws Exception{
    int x = 0;
    for(int i = 850000; i>0; i--) {
        publish(x); //replace x with the number you want to increment the progressbar each time pubish is called
        x = x + i; //or replace i with the increment you want
        System.out.println("i = " + i);
    }
  }

  @Override
  protected void done(){
    try{
      get();
    }catch(ExecutionException |InterruptedException e){
      ;
    }
  }

}

---

下面是一个完整的示例，使用

导入java.awt.BorderLayout；
导入java.awt.EventQueue；
导入java.util.List；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入javax.swing.JProgressBar；
导入javax.swing.SwingWorker；
导入javax.swing.border.EmptyBorder；
公共类ProgressBarTest扩展了JFrame{
专用静态最终长循环长度=85000000；
私有JPanel内容窗格；
/**
*启动应用程序。
*/
公共静态void main（字符串[]args）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
ProgressBarTest帧=新的ProgressBarTest（）；
frame.setVisible（true）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
});
}
/**
*创建框架。
*/
公共工程{
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
立根（100100450300）；
contentPane=newjpanel（）；
setboorder（新的EmptyBorder（5,5,5,5））；
setLayout（新的BorderLayout（0,0））；
JProgressBar进度=新建JProgressBar（）；
进度。设置字符串绘制（真）；
添加（新的JLabel（“循环进度为：”），BorderLayout.NORTH）；
添加（进度，BorderLayout.SOUTH）；
setContentPane（contentPane）；
ProgressWorker=新的ProgressWorker（进度）；
worker.execute（）；
}
私有静态类ProgressWorker扩展SwingWorker{
私人最终JProgressBar进度；
公共进步工作者（JProgressBar进步）{
这个。进步=进步；
}
@凌驾
受保护的Void doInBackground（）引发异常{
对于（长i=循环长度；i>0；i--）{
最终整数程序=（整数）（（100L*（循环长度-i））/循环长度）；
出版（progr）；
}
返回null；
}
@凌驾
受保护的无效进程（列表块）{
setValue（chunks.get（chunks.size（）-1））；
超级进程（块）；
}
@凌驾
受保护的void done（）{
进度。设定值（100）；
}
}
}

以下是完整的示例，使用的是

导入java.awt.BorderLayout；
导入java.awt.EventQueue；
导入java.util.List；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入javax.swing.JProgressBar；
导入javax.swing.SwingWorker；
导入javax.swing.border.EmptyBorder；
公共类ProgressBarTest扩展了JFrame{
专用静态最终长循环长度=85000000；
私有JPanel内容窗格；
/**
*启动应用程序。
*/
公共静态void main（字符串[]args）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
ProgressBarTest帧=新的ProgressBarTest（）；
frame.setVisible（true）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
});
}
/**
*创建框架。
*/
公共工程{
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
立根（100100450300）；
contentPane=newjpanel（）；
setboorder（新的EmptyBorder（5,5,5,5））；
setLayout（新的BorderLayout（0,0））；
JProgressBar进度=新建JProgressBar（）；
进度。设置字符串绘制（真）；
添加（新的JLabel（“循环进度为：”），BorderLayout.NORTH）；
添加（进度，BorderLayout.SOUTH）；
setContentPane（contentPane）；
ProgressWorker=新的ProgressWorker（进度）；
worker.execute（）；
}
私有静态类ProgressWorker扩展SwingWorker{
私人最终JProgressBar进度；
公共进步工作者（JProgressBar进步）{
这个。进步=进步；
}
@凌驾
受保护的Void doInBackground（）引发异常{
对于（长i=循环长度；i>0；i--）{
最终整数程序=（整数）（（100L*（循环长度-i））/循环长度）；
出版（progr）；
}
返回null；
}
@凌驾
受保护的无效进程（列表块）{
setValue（chunks.get（chunks.size（）-1））；
超级进程（块）；
}
@凌驾
受保护的void done（）{
进度。设定值（100）；
}
}
}

使用SwingWorker、doInBackground（）和publish（）。谢谢这对我很有用。使用SwingWorker、doInBackground（）和publish（）。谢谢这对我很有用。这太棒了。我用过Sergiy

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.SwingWorker;
import javax.swing.border.EmptyBorder;

public class ProgressBarTest extends JFrame {

    private static final long LOOP_LENGTH = 85000000;

    private JPanel contentPane;

    /**
     * Launch the application.
     */
    public static void main(String[] args) {

        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    ProgressBarTest frame = new ProgressBarTest();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    /**
     * Create the frame.
     */
    public ProgressBarTest() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        JProgressBar progress = new JProgressBar();
        progress.setStringPainted(true);
        contentPane.add(new JLabel("Loop progress is: "), BorderLayout.NORTH);
        contentPane.add(progress, BorderLayout.SOUTH);
        setContentPane(contentPane);
        ProgressWorker worker = new ProgressWorker(progress);
        worker.execute();
    }

    private static class ProgressWorker extends SwingWorker<Void, Integer> {
        private final JProgressBar progress;

        public ProgressWorker(JProgressBar progress) {
            this.progress = progress;
        }

        @Override
        protected Void doInBackground() throws Exception {
            for (long i = LOOP_LENGTH; i > 0; i--) {
                final int progr = (int) ((100L * (LOOP_LENGTH - i)) / LOOP_LENGTH);
                publish(progr);
            }
            return null;
        }

        @Override
        protected void process(List<Integer> chunks) {
            progress.setValue(chunks.get(chunks.size() - 1));
            super.process(chunks);
        }

        @Override
        protected void done() {
            progress.setValue(100);
        }
    }
}