复制目录和文件时，需要使用JProgress栏来衡量进度 [英] Need to have JProgress bar to measure progress when copying directories and files

问题描述

我有下面的代码来复制目录和文件，但不知道在哪里测量进度。有人可以帮助

在哪里可以测量多少已被复制，并显示在JProgress栏中

 <$ c $ （$ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ s $ {目标目录是否存在
 dest.mkdir（）; 
 System.out.println（从
 + src +复制到+ dest的目录）; 
} 
 
字符串文件[] = src.list（）; 
 
（String file：files）{
 
文件srcFile = new File（src，file）; 
文件destFile =新文件（dest，file）; 
 
 copyFolder（srcFile，destFile）; 
} 
} else {
 InputStream in = new FileInputStream（src）; 
 OutputStream out = new FileOutputStream（dest）; 
 
 byte [] buffer = new byte [1024]; 
 
 int长度; （（length = in.read（buffer））> 0）{
 out.write（buffer，0，length）; 
 
 while 
} 
 
 in.close（）; 
 out.close（）; 
 System.out.println（将文件从+ src +复制到+ dest）; 
 
  

解决方案

为你:)（这需要我约3小时）：

  import java.awt.BorderLayout; 
 import java.awt.event.ActionEvent; 
 import java.awt.event.ActionListener; 
 import java.awt.event.WindowAdapter; 
 import java.awt.event.WindowEvent; 
 import java.beans.PropertyChangeEvent; 
 import java.beans.PropertyChangeListener; 
 import java.io.BufferedInputStream; 
 import java.io.BufferedOutputStream; 
 import java.io.File; 
 import java.io.FileInputStream; 
 import java.io.FileOutputStream; 
 import java.io.IOException; 
 import java.util.List; 
 
 import javax.swing.BorderFactory; 
 import javax.swing.JButton; 
 import javax.swing.JFrame; 
 import javax.swing.JLabel; 
 import javax.swing.JOptionPane; 
 import javax.swing.JPanel; 
 import javax.swing.JProgressBar; 
 import javax.swing.JScrollPane; 
 import javax.swing.JTextArea; 
 import javax.swing.JTextField; 
导入javax.swing.SwingUtilities; 
 import javax.swing.SwingWorker; 
 import javax.swing.event.DocumentEvent; 
 import javax.swing.event.DocumentListener; 
 import javax.swing.text.DefaultCaret; 
 
 public class FileCopierUtility extends JFrame implements ActionListener，PropertyChangeListener 
 {
 private static final long serialVersionUID = 1L; 
 
私人JTextField txtSource; 
 private JTextField txtTarget; 
私人JProgressBar progressAll; 
私人JProgressBar progressCurrent; 
 private JTextArea txtDetails; 
私人JButton btnCopy; 
私人CopyTask任务; 
 
 public FileCopierUtility（）
 {
 buildGUI（）; 
 
 $ b $ private void buildGUI（）
 {
 setTitle（File Copier Utility）; 
 setDefaultCloseOperation（DO_NOTHING_ON_CLOSE）; 
 
 addWindowListener（new WindowAdapter（）
 {
 @Override 
 public void windowClosing（WindowEvent e）
 {
 if（task！ null）task.cancel（true）; 
 dispose（）; 
 System.exit（0）; 
} 
}）; 
 
 JLabel lblSource = new JLabel（Source Path：）; 
 JLabel lblTarget = new JLabel（Target Path：）; 
 txtSource = new JTextField（50）; 
 txtTarget = new JTextField（50）; 
 JLabel lblProgressAll = new JLabel（Overall：）; 
 JLabel lblProgressCurrent = new JLabel（当前文件：）; 
 progressAll = new JProgressBar（0，100）; 
 progressAll.setStringPainted（true）; 
 progressCurrent = new JProgressBar（0，100）; 
 progressCurrent.setStringPainted（true）; 
 txtDetails = new JTextArea（5，50）; 
 txtDetails.setEditable（false）; 
 DefaultCaret caret =（DefaultCaret）txtDetails.getCaret（）; 
 caret.setUpdatePolicy（DefaultCaret.ALWAYS_UPDATE）; 
 JScrollPane scrollPane = new JScrollPane（txtDetails，JScrollPane.VERTICAL_SCROLLBAR_​​AS_NEEDED，JScrollPane.HORIZONTAL_SCROLLBAR_​​AS_NEEDED）; 
 btnCopy = new JButton（Copy）; 
 btnCopy.setFocusPainted（false）; 
 btnCopy.setEnabled（false）; 
 btnCopy.addActionListener（this）; 
 
 DocumentListener listener = new DocumentListener（）
 {
 @Override 
 public void removeUpdate（DocumentEvent e）
 {
 boolean bEnabled = txtSource .getText（）。length（）> 0&& txtTarget.getText（）。length（）> 0; 
 btnCopy.setEnabled（bEnabled）; 
 
 $ b @Override 
 public void insertUpdate（DocumentEvent e）
 {
 boolean bEnabled = txtSource.getText（）。length（）> 0&& txtTarget.getText（）。length（）> 0; 
 btnCopy.setEnabled（bEnabled）; 
} 
 
 @Override 
 public void changedUpdate（DocumentEvent e）{} 
}; 
 
 txtSource.getDocument（）。addDocumentListener（listener）; 
 txtTarget.getDocument（）。addDocumentListener（listener）; 
 
 JPanel contentPane =（JPanel）getContentPane（）; 
 contentPane.setBorder（BorderFactory.createEmptyBorder（5，5，5））; 
 
 JPanel panInputLabels = new JPanel（new BorderLayout（0，5））; 
 JPanel panInputFields = new JPanel（new BorderLayout（0，5））; 
 JPanel panProgressLabels = new JPanel（new BorderLayout（0，5））; 
 JPanel panProgressBars = new JPanel（new BorderLayout（0，5））; 
 
 panInputLabels.add（lblSource，BorderLayout.NORTH）; 
 panInputLabels.add（lblTarget，BorderLayout.CENTER）; 
 panInputFields.add（txtSource，BorderLayout.NORTH）; 
 panInputFields.add（txtTarget，BorderLayout.CENTER）; 
 panProgressLabels.add（lblProgressAll，BorderLayout.NORTH）; 
 panProgressLabels.add（lblProgressCurrent，BorderLayout.CENTER）; 
 panProgressBars.add（progressAll，BorderLayout.NORTH）; 
 panProgressBars.add（progressCurrent，BorderLayout.CENTER）; 
 
 JPanel panInput = new JPanel（new BorderLayout（0，5））; 
 panInput.setBorder（BorderFactory.createCompoundBorder（BorderFactory.createTitledBorder（Input），BorderFactory.createEmptyBorder（5，5，5）））; 
 JPanel panProgress = new JPanel（new BorderLayout（0，5））; 
 panProgress.setBorder（BorderFactory.createCompoundBorder（BorderFactory.createTitledBorder（Progress），BorderFactory.createEmptyBorder（5，5，5）））; 
 JPanel panDetails = new JPanel（new BorderLayout（））; 
 panDetails.setBorder（BorderFactory.createCompoundBorder（BorderFactory.createTitledBorder（Details），BorderFactory.createEmptyBorder（5，5，5）））; 
 JPanel panControls = new JPanel（new BorderLayout（））; 
 panControls.setBorder（BorderFactory.createEmptyBorder（5，0，5，0））; 
 
 panInput.add（panInputLabels，BorderLayout.LINE_START）; 
 panInput.add（panInputFields，BorderLayout.CENTER）; 
 panProgress.add（panProgressLabels，BorderLayout.LINE_START）; 
 panProgress.add（panProgressBars，BorderLayout.CENTER）; 
 panDetails.add（scrollPane，BorderLayout.CENTER）; 
 panControls.add（btnCopy，BorderLayout.CENTER）; 
 
 JPanel panUpper = new JPanel（new BorderLayout（））; 
 panUpper.add（panInput，BorderLayout.NORTH）; 
 panUpper.add（panProgress，BorderLayout.SOUTH）; 
 
 contentPane.add（panUpper，BorderLayout.NORTH）; 
 contentPane.add（panDetails，BorderLayout.CENTER）; 
 contentPane.add（panControls，BorderLayout.SOUTH）; 
 
 pack（）; 
 setLocationRelativeTo（null）; 
 
 $ b @覆盖
 public void actionPerformed（ActionEvent e）
 {
 if（Copy.equals（btnCopy.getText（））） 
 {
 File source = new File（txtSource.getText（））; 
 File target = new File（txtTarget.getText（））; 
 $ b $ if（！source.exists（））
 {
 JOptionPane.showMessageDialog（这个源文件/目录不存在！，ERROR，JOptionPane。错误信息）; 
 return; $！
 
 
 if（！target.exists（）&& source.isDirectory（））target.mkdirs（）; 
 else 
 {
 int option = JOptionPane.showConfirmDialog（this，目标文件/目录已经存在，是否要覆盖它？，Overwrite the target，JOptionPane.YES_NO_OPTION ）; 
 if（option！= JOptionPane.YES_OPTION）return; 
} 
 
 task = this.new CopyTask（source，target）; 
 task.addPropertyChangeListener（this）; 
 task.execute（）; 
 
 btnCopy.setText（取消）; 
 
 else if（Cancel.equals（btnCopy.getText（）））
 {
 task.cancel（true）; 
 btnCopy.setText（Copy）; 
 
 
 $ b @Override 
 public void propertyChange（PropertyChangeEvent evt）
 {
 if（progress.equals（evt。 getPropertyName（）））
 {
 int progress =（Integer）evt.getNewValue（）; 
 progressAll.setValue（progress）; 
 
 
 $ b $ public static void main（String [] args）
 {
 SwingUtilities.invokeLater（new Runnable（）
 { 
 @Override 
 public void run（）
 {
 new FileCopierUtility（）。setVisible（true）; 
} 
}）; 
} 
 
 class CopyTask扩展了SwingWorker< Void，Integer> 
 {
私有文件源; 
私有文件目标; 
私人长期总费用= 0L; 
 private long copiedBytes = 0L; 
 
 public CopyTask（文件源，文件目标）
 {
 this.source = source; 
 this.target = target; 
 
 progressAll.setValue（0）; 
 progressCurrent.setValue（0）; 
 
 $ b @Override 
 public void doInBackground（）throws Exception 
 {
 txtDetails.append（Retrieving some info ...）; 
 retrieveTotalBytes（source）; 
 txtDetails.append（Done！\\\
）; 
 
 copyFiles（source，target）; 
返回null; 
 
 $ b @覆盖
 public void process（List< Integer> chunks）
 {
 for（int i：chunk）
 { 
 progressCurrent.setValue（i）; 
 
 
 $ b @Override 
 public void done（）
 {
 setProgress（100）; 
 btnCopy.setText（Copy）; 
 
 $ b $ private void retrieveTotalBytes（File sourceFile）
 {
 File [] files = sourceFile.listFiles（）; 
 for（File file：files）
 {
 if（file.isDirectory（））retrieveTotalBytes（file）; 
 else totalBytes + = file.length（）; 
 
 
 
 private void copyFiles（File sourceFile，File targetFile）throws IOException 
 {
 if（sourceFile.isDirectory（））
（
 if（！targetFile.exists（））targetFile.mkdirs（）; 
 
 String [] filePaths = sourceFile.list（）; （String filePath：filePaths）
 
 
 {
文件srcFile = new File（sourceFile，filePath）; 
文件destFile =新文件（targetFile，filePath）; 
 
 copyFiles（srcFile，destFile）; 
 
 
 
 
 txtDetails.append（Copying+ sourceFile.getAbsolutePath（）+...）; 
 
 BufferedInputStream bis = new BufferedInputStream（new FileInputStream（sourceFile））; 
 BufferedOutputStream bos = new BufferedOutputStream（new FileOutputStream（targetFile））; 
 
 long fileBytes = sourceFile.length（）; 
 long soFar = 0L; 
 
 int theByte; （（theByte = bis.read（））！= -1）
 
（
 bos.write（theByte）; 
 
 setProgress（（int）（copiedBytes ++ * 100 / totalBytes））; 
发布（（int）（soFar ++ * 100 / fileBytes））; 
} 
 
 bis.close（）; 
 bos.close（）; 
 
发布（100）; 
 
 txtDetails.append（Done！\\\
）; 
} 
} 
} 
} 
  

I have the below code to copy directories and files but not sure where to measure the progress. Can someone help
as to where can I measure how much has been copied and show it in the JProgress bar

public static void copy(File src, File dest)
throws IOException{
if(src.isDirectory()){
        if(!dest.exists()){ //checking whether destination directory exisits
           dest.mkdir();
           System.out.println("Directory copied from " 
                        + src + "  to " + dest);
        }

        String files[] = src.list();

        for (String file : files) {

           File srcFile = new File(src, file);
           File destFile = new File(dest, file);

           copyFolder(srcFile,destFile);
        }
  }else{
        InputStream in = new FileInputStream(src);
          OutputStream out = new FileOutputStream(dest); 

          byte[] buffer = new byte[1024];

          int length;

          while ((length = in.read(buffer)) > 0){
           out.write(buffer, 0, length);
          }

          in.close();
          out.close();
          System.out.println("File copied from " + src + " to " + dest);
  }

解决方案

I have just written this utility for you :) (It takes me about 3 hours):

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;

import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.DefaultCaret;

public class FileCopierUtility extends JFrame implements ActionListener, PropertyChangeListener
{
    private static final long serialVersionUID = 1L;

    private JTextField txtSource;
    private JTextField txtTarget;
    private JProgressBar progressAll;
    private JProgressBar progressCurrent;
    private JTextArea txtDetails;
    private JButton btnCopy;
    private CopyTask task;

    public FileCopierUtility()
    {
        buildGUI();
    }

    private void buildGUI()
    {
        setTitle("File Copier Utility");
        setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);

        addWindowListener(new WindowAdapter()
        {
            @Override
            public void windowClosing(WindowEvent e)
            {
                if(task != null) task.cancel(true);
                dispose();
                System.exit(0);
            }
        });

        JLabel lblSource = new JLabel("Source Path: ");
        JLabel lblTarget = new JLabel("Target Path: ");
        txtSource = new JTextField(50);
        txtTarget = new JTextField(50);
        JLabel lblProgressAll = new JLabel("Overall: ");
        JLabel lblProgressCurrent = new JLabel("Current File: ");
        progressAll = new JProgressBar(0, 100);
        progressAll.setStringPainted(true);
        progressCurrent = new JProgressBar(0, 100);
        progressCurrent.setStringPainted(true);
        txtDetails = new JTextArea(5, 50);
        txtDetails.setEditable(false);
        DefaultCaret caret = (DefaultCaret) txtDetails.getCaret();
        caret.setUpdatePolicy(DefaultCaret.ALWAYS_UPDATE);
        JScrollPane scrollPane = new JScrollPane(txtDetails, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        btnCopy = new JButton("Copy");
        btnCopy.setFocusPainted(false);
        btnCopy.setEnabled(false);
        btnCopy.addActionListener(this);

        DocumentListener listener = new DocumentListener()
        {
            @Override
            public void removeUpdate(DocumentEvent e)
            {
                boolean bEnabled = txtSource.getText().length() > 0 && txtTarget.getText().length() > 0;
                btnCopy.setEnabled(bEnabled);
            }

            @Override
            public void insertUpdate(DocumentEvent e)
            {
                boolean bEnabled = txtSource.getText().length() > 0 && txtTarget.getText().length() > 0;
                btnCopy.setEnabled(bEnabled);
            }

            @Override
            public void changedUpdate(DocumentEvent e){}
        };

        txtSource.getDocument().addDocumentListener(listener);
        txtTarget.getDocument().addDocumentListener(listener);

        JPanel contentPane = (JPanel) getContentPane();
        contentPane.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

        JPanel panInputLabels = new JPanel(new BorderLayout(0, 5));
        JPanel panInputFields = new JPanel(new BorderLayout(0, 5));
        JPanel panProgressLabels = new JPanel(new BorderLayout(0, 5));
        JPanel panProgressBars = new JPanel(new BorderLayout(0, 5));

        panInputLabels.add(lblSource, BorderLayout.NORTH);
        panInputLabels.add(lblTarget, BorderLayout.CENTER);
        panInputFields.add(txtSource, BorderLayout.NORTH);
        panInputFields.add(txtTarget, BorderLayout.CENTER);
        panProgressLabels.add(lblProgressAll, BorderLayout.NORTH);
        panProgressLabels.add(lblProgressCurrent, BorderLayout.CENTER);
        panProgressBars.add(progressAll, BorderLayout.NORTH);
        panProgressBars.add(progressCurrent, BorderLayout.CENTER);

        JPanel panInput = new JPanel(new BorderLayout(0, 5));
        panInput.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createTitledBorder("Input"), BorderFactory.createEmptyBorder(5, 5, 5, 5)));
        JPanel panProgress = new JPanel(new BorderLayout(0, 5));
        panProgress.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createTitledBorder("Progress"), BorderFactory.createEmptyBorder(5, 5, 5, 5)));
        JPanel panDetails = new JPanel(new BorderLayout());
        panDetails.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createTitledBorder("Details"), BorderFactory.createEmptyBorder(5, 5, 5, 5)));
        JPanel panControls = new JPanel(new BorderLayout());
        panControls.setBorder(BorderFactory.createEmptyBorder(5, 0, 5, 0));

        panInput.add(panInputLabels, BorderLayout.LINE_START);
        panInput.add(panInputFields, BorderLayout.CENTER);
        panProgress.add(panProgressLabels, BorderLayout.LINE_START);
        panProgress.add(panProgressBars, BorderLayout.CENTER);
        panDetails.add(scrollPane, BorderLayout.CENTER);
        panControls.add(btnCopy, BorderLayout.CENTER);

        JPanel panUpper = new JPanel(new BorderLayout());
        panUpper.add(panInput, BorderLayout.NORTH);
        panUpper.add(panProgress, BorderLayout.SOUTH);

        contentPane.add(panUpper, BorderLayout.NORTH);
        contentPane.add(panDetails, BorderLayout.CENTER);
        contentPane.add(panControls, BorderLayout.SOUTH);

        pack();
        setLocationRelativeTo(null);
    }

    @Override
    public void actionPerformed(ActionEvent e)
    {
        if("Copy".equals(btnCopy.getText()))
        {
            File source = new File(txtSource.getText());
            File target = new File(txtTarget.getText());

            if(!source.exists())
            {
                JOptionPane.showMessageDialog(this, "The source file/directory does not exist!", "ERROR", JOptionPane.ERROR_MESSAGE);
                return;
            }

            if(!target.exists() && source.isDirectory()) target.mkdirs();
            else
            {
                int option = JOptionPane.showConfirmDialog(this, "The target file/directory already exists, do you want to overwrite it?", "Overwrite the target", JOptionPane.YES_NO_OPTION);
                if(option != JOptionPane.YES_OPTION) return;
            }

            task = this.new CopyTask(source, target);
            task.addPropertyChangeListener(this);
            task.execute();

            btnCopy.setText("Cancel");
        }
        else if("Cancel".equals(btnCopy.getText()))
        {
            task.cancel(true);
            btnCopy.setText("Copy");
        }
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt)
    {
        if("progress".equals(evt.getPropertyName()))
        {
            int progress = (Integer) evt.getNewValue();
            progressAll.setValue(progress);
        }
    }

    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(new Runnable()
        {   
            @Override
            public void run()
            {
                new FileCopierUtility().setVisible(true);
            }
        });
    }

    class CopyTask extends SwingWorker<Void, Integer>
    {
        private File source;
        private File target;
        private long totalBytes = 0L;
        private long copiedBytes = 0L;

        public CopyTask(File source, File target)
        {
            this.source = source;
            this.target = target;

            progressAll.setValue(0);
            progressCurrent.setValue(0);
        }

        @Override
        public Void doInBackground() throws Exception
        {
            txtDetails.append("Retrieving some info ... ");
            retrieveTotalBytes(source);
            txtDetails.append("Done!\n");

            copyFiles(source, target);
            return null;
        }

        @Override
        public void process(List<Integer> chunks)
        {
            for(int i : chunks)
            {
                progressCurrent.setValue(i);
            }
        }

        @Override
        public void done()
        {
            setProgress(100);
            btnCopy.setText("Copy");
        }

        private void retrieveTotalBytes(File sourceFile)
        {
            File[] files = sourceFile.listFiles();
            for(File file : files)
            {
                if(file.isDirectory()) retrieveTotalBytes(file);
                else totalBytes += file.length();
            }
        }

        private void copyFiles(File sourceFile, File targetFile) throws IOException
        {
            if(sourceFile.isDirectory())
            {
                if(!targetFile.exists()) targetFile.mkdirs();

                String[] filePaths = sourceFile.list();

                for(String filePath : filePaths)
                {
                    File srcFile = new File(sourceFile, filePath);
                    File destFile = new File(targetFile, filePath);

                    copyFiles(srcFile, destFile);
                }
            }
            else
            {
                txtDetails.append("Copying " + sourceFile.getAbsolutePath() + " ... ");

                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceFile));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(targetFile));

                long fileBytes = sourceFile.length();
                long soFar = 0L;

                int theByte;

                while((theByte = bis.read()) != -1)
                {
                    bos.write(theByte);

                    setProgress((int) (copiedBytes++ * 100 / totalBytes));
                    publish((int) (soFar++ * 100 / fileBytes));
                }

                bis.close();
                bos.close();

                publish(100);

                txtDetails.append("Done!\n");
            }
        }
    }
}

这篇关于复制目录和文件时，需要使用JProgress栏来衡量进度的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！