Java压缩/解压缩文件或目录组件FileArchive(附可执行程序下载)
1. 测试程序最终截图
2. 定义组件支持的算法
3. 定义组件抽象父类
4. 压缩文件或目录实现
5. 解压缩文件实现
6. 定义回掉函数，作为组件监听器
7. 组件核心控制器
8. 核心测试代码
2. 定义组件支持的算法
package org.file.util.archive;
/**
* @author ALLEN
* <br/>Define the compress algorithm
* <br/>Support <b>{ Compress, UnCompress }</b>
*/
public enum Algorithm {
Compress, /* Compress Algorithm */
UnCompress /* UnCompress Algorithm */
}
3. 定义组件抽象父类
package org.file.util.archive;
import java.io.File;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
/**
* @author ALLEN
* <br/>Define the parent case collection of Compress and UnCompress
*/
public abstract class Archive {
/**
* Define the default compress level { 9 }
*/
public static final int DEFAULT_COMPRESS_LEVEL = 9;
/**
* Define the default buffer size { 2 << 19 = 1MB }
*/
protected static final int DEFAULT_BUFFER_SIZE = 2 << 19;
/**
* Define the default file block { 100 }
*/
protected static final int DEFAULT_FILE_BLOCK = 100;
/**
* Define the archive algorithm
*/
protected Algorithm algorithm;
/**
* Define the ZIP file instance
*/
protected File zipFile;
/**
* Define the meta files instance
*/
protected File[] metaFiles;
/**
* Define the bytes which has finished reading
*/
protected long finished = 0L;
/**
* Define the current total compressed size
*/
protected long compressSize = 0L;
/**
* Define the total bytes of (sub)file(s)
*/
protected long total = 0L;
/**
* Define the task startup time
*/
protected long start = System.currentTimeMillis();
/**
* Define the task progress current time
*/
protected long current = this.start;
/**
* Define the properties instance
*/
protected final Properties properties = new Properties();
/**
* Define the progress listener linked list collection
*/
protected final List<ProgressListener> listeners = new LinkedList<ProgressListener>();
/**
* The default constructor
* @param algorithm
* the archive algorithm
* @param zipFile
* the ZIP file instance
* @param metaFiles
* the meta files array
*/
protected Archive(Algorithm algorithm, File zipFile, File... metaFiles) {
if (algorithm != null && zipFile != null) {
this.algorithm = algorithm;
this.zipFile = zipFile;
this.metaFiles = metaFiles;
this.properties.clear();
this.listeners.clear();
this.init();
}
}
/**
* Initialize the compress or uncompress components
*/
protected abstract void init();
/**
* The core compress and uncompress process
*/
protected abstract void process();
/**
* Notify all registered progress listeners
*/
protected void notifyListeners() {
for (ProgressListener listener : this.listeners)
listener.progress(this.finished, this.compressSize, this.total, this.start, this.current, this.properties);
}
/**
* Register a new progress listener into the listeners linked list
* @param listener
* the ProgressListener instance
*/
public void registerProgressListener(ProgressListener listener) {
if (listener != null)
synchronized (this.listeners) {
this.listeners.add(listener);
}
}
/**
* Remove a progress listener from the listeners linked list
* @param listener
* the ProgressListener instance
*/
public void removeProgressListener(ProgressListener listener) {
if (listener != null)
synchronized (this.listeners) {
this.listeners.remove(listener);
}
}
/**
* Start the process task to execute
*/
public void execute() {
synchronized (this) {
this.process();
}
}
}
4. 压缩文件或目录实现
package org.file.util.archive;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
/**
* @author ALLEN
* <br/>The child Compress implement from archive
*/
public class Compress extends Archive {
/**
* Define the file collection vector
*/
private Map<String, File> hashMap;
/**
* Define the compress level
*/
private int level = DEFAULT_COMPRESS_LEVEL;
/**
* Define the compress comment
*/
private String comment = null;
/**
* The default constructor
* @param algorithm
* the archive algorithm
* @param zipFile
* the ZIP file instance
* @param metaFiles
* the meta files array
*/
protected Compress(Algorithm algorithm, File zipFile, File... metaFiles) {
super(algorithm, zipFile, metaFiles);
}
/**
* The recursive method which scans the file instance
*/
private void scan() {
for (File file : this.metaFiles) {
if (file.isFile()) {
this.total += file.length();
this.hashMap.put(file.getName(), file);
}
else if (file.isDirectory())
this.make(file, file.getAbsolutePath().length() + 1);
}
}
/**
* The recursive method which make new file record
* @param file
* the destination directory instance
* @param cutPos
* the parent directory cut position of current file
*/
private void make(File file, int cutPos) {
for (File tmp : file.listFiles()) {
if (tmp.isFile()) {
this.total += tmp.length();
this.hashMap.put(tmp.getAbsolutePath().substring(cutPos), tmp);
} else if (tmp.isDirectory())
this.make(tmp, cutPos);
}
}
/**
* Set the compress level and comment
* @param level
* the compress level
* @param comment
* the compress comment
*/
public void setLevelAndComment(int level, String comment) {
if (level > 0 && level < 10)
this.level = level;
this.comment = comment;
}
/* (non-Javadoc)
* @see org.file.util.archive.Archive#init()
*/
protected void init() {
this.hashMap = new HashMap<String, File>();
this.hashMap.clear();
this.scan();
}
/* (non-Javadoc)
* @see org.file.util.archive.Archive#process()
*/
protected void process() {
try {
// update compressed size
this.compressSize = this.total;
// create output stream instance
ZipOutputStream output = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(this.zipFile, false)));
output.setLevel(this.level);
output.setComment(this.comment);
// define the input parameters
BufferedInputStream input = null;
long fileLength = 0L;
int bufferSize = 0;
int length = -1;
byte[] buffer = null;
// parser files
Iterator<String> it = this.hashMap.keySet().iterator();
if (it != null) {
this.properties.setProperty("Count", String.valueOf(this.hashMap.size()));
this.start = System.currentTimeMillis();
while (it.hasNext()) {
// get file information
String relativePath = it.next();
File file = this.hashMap.get(relativePath);
// assign buffer size
if ((fileLength = file.length()) < 0)
continue;
if (fileLength < DEFAULT_FILE_BLOCK)
bufferSize = (int)fileLength;
else if (Math.round((double)fileLength / DEFAULT_FILE_BLOCK) < DEFAULT_BUFFER_SIZE)
bufferSize = DEFAULT_BUFFER_SIZE;
else
bufferSize = (int)Math.round((double)fileLength / DEFAULT_FILE_BLOCK);
buffer = new byte[bufferSize];
// create new file entry
output.putNextEntry(new ZipEntry(relativePath));
input = new BufferedInputStream(new FileInputStream(file), bufferSize);
while ((length = input.read(buffer, 0, bufferSize)) != -1) {
// update finished value
this.finished += length;
output.write(buffer, 0, length);
// update current time value
this.current = System.currentTimeMillis();
// notify progress listeners
this.notifyListeners();
}
input.close();
}
}
output.flush();
output.close();
// update compressed size
ZipFile zf = new ZipFile(this.zipFile.getAbsolutePath());
this.compressSize = 0L;
Iterator<String> _it = this.hashMap.keySet().iterator();
while (_it.hasNext())
this.compressSize += zf.getEntry(_it.next()).getCompressedSize();
zf.close();
this.notifyListeners();
} catch (Exception e) {
;
}
}
}
5. 解压缩文件实现
package org.file.util.archive;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
/**
* @author ALLEN
* <br/>The child UnCompress implement from archive
*/
public class UnCompress extends Archive {
/**
* Define the file entry collection
*/
private Vector<String> vector;
/**
* The default constructor
* @param algorithm
* the archive algorithm
* @param zipFile
* the ZIP file instance
* @param metaFile
* the meta directory
*/
protected UnCompress(Algorithm algorithm, File zipFile, File metaFile) {
super(algorithm, zipFile, metaFile);
}
/**
* Scan the ZIP compress file entries
*/
private void scan() {
try {
ZipFile zf = new ZipFile(this.zipFile.getAbsolutePath());
Enumeration<?> en = zf.entries();
if (en != null) {
while (en.hasMoreElements())
this.vector.add(((ZipEntry)en.nextElement()).getName());
}
zf.close();
this.properties.setProperty("Count", String.valueOf(zf.size()));
} catch (Exception e) {
;
}
}
/* (non-Javadoc)
* @see org.file.util.archive.Archive#init()
*/
protected void init() {
this.vector = new Vector<String>();
this.vector.clear();
this.scan();
}
/* (non-Javadoc)
* @see org.file.util.archive.Archive#process()
*/
protected void process() {
File path = null;
if (this.metaFiles.length != 1 || !(path = this.metaFiles[0]).isDirectory())
return;
try {
// create ZIP file instance
ZipFile zf = new ZipFile(this.zipFile);
Iterator<String> _it = this.vector.iterator();
while (_it.hasNext()) {
ZipEntry entry = zf.getEntry(_it.next());
this.compressSize += entry.getCompressedSize();
this.total += entry.getSize();
}
// define uncompress parameters
InputStream input = null;
String absolutePath = null;
File tmp = null;
OutputStream output = null;
long entryLength = 0L;
int bufferSize = 0;
int length = -1;
byte[] buffer;
// create iterator
Iterator<String> it = this.vector.iterator();
if (it != null) {
this.start = System.currentTimeMillis();
while (it.hasNext()) {
// get file entry relative path
String relativePath = it.next();
ZipEntry entry = zf.getEntry(relativePath);
// assign buffer size
if ((entryLength = entry.getCompressedSize()) < 0)
continue;
if (entryLength < DEFAULT_FILE_BLOCK)
bufferSize = (int)entryLength;
else if (Math.round((double)entryLength / DEFAULT_FILE_BLOCK) < DEFAULT_BUFFER_SIZE)
bufferSize = DEFAULT_BUFFER_SIZE;
else
bufferSize = (int)Math.round((double)entryLength / DEFAULT_FILE_BLOCK);
buffer = new byte[bufferSize];
// get input stream instance
input = zf.getInputStream(entry);
// create file is not exist
absolutePath = path.getAbsolutePath() + System.getProperty("file.separator") + relativePath;
tmp = new File(absolutePath.substring(0, absolutePath.lastIndexOf(System.getProperty("file.separator"))));
tmp.mkdirs();
tmp = new File(absolutePath);
tmp.createNewFile();
// uncompress data
output = new BufferedOutputStream(new FileOutputStream(tmp, false), bufferSize);
while ((length = input.read(buffer, 0, bufferSize)) != -1) {
// update finished value
this.finished += length;
output.write(buffer, 0, length);
// update current time value
this.current = System.currentTimeMillis();
// notify progress listeners
this.notifyListeners();
}
output.flush();
output.close();
input.close();
}
}
zf.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
6. 定义回掉函数，作为组件监听器
package org.file.util.archive;
import java.util.Properties;
/**
* @author ALLEN
* <br/>Define the archive progress listener
*/
public interface ProgressListener {
/**
* Define the progress listener method which can read the archive progress
* @param finished
* the total bytes finished handling
* @param compressSize
* the current total compress size
* @param total
* the total bytes of data
* @param start
* the start time of progress
* @param current
* the current time of progress
* @param properties
* the result properties of archive
* <br/>properties key should be in <b>{ Count }<b/>
*/
public void progress(long finished, long compressSize, long total, long start, long current, Properties properties);
}
7. 组件核心控制器
package org.file.util.archive;
import java.io.File;
/**
* @author ALLEN
* <br/>Define the FileArchive which manages Compress and UnCompress
*/
public class FileArchive implements Runnable {
/**
* Define the archive instance
*/
private Archive archive;
/**
* The default constructor
* @param algorithm
* the archive algorithm
* @param zipFile
* the destination ZIP file
* @param metaFiles
* the meta files
*/
private FileArchive(Algorithm algorithm, File zipFile, File... metaFiles) {
if (algorithm == Algorithm.Compress) {
this.archive = new Compress(algorithm, zipFile, metaFiles);
} else if (algorithm == Algorithm.UnCompress) {
metaFiles[0].mkdirs();
this.archive = new UnCompress(algorithm, zipFile, metaFiles[0]);
}
}
/**
* Return an instance of FileArchive
* @param algorithm
* the archive algorithm
* @param absolutePath
* the destination ZIP file
* @param metaFiles
* the meta files
* @return
* a new instance of FileArchive
*/
public static FileArchive getInstance(Algorithm algorithm, String absolutePath, String... metaFiles) {
return getInstance(algorithm, new File(absolutePath), metaFiles);
}
/**
* Return an instance of FileArchive
* @param algorithm
* the archive algorithm
* @param zipFile
* the destination ZIP file
* @param metaFiles
* the meta files
* @return
* a new instance of FileArchive
*/
public static FileArchive getInstance(Algorithm algorithm, File zipFile, String... metaFiles) {
if (metaFiles != null) {
int length = metaFiles.length;
File[] files = new File[length];
for (int i = 0; i < length; i++)
files[i] = new File(metaFiles[i]);
return getInstance(algorithm, zipFile, files);
} else
return null;
}
/**
* Return an instance of FileArchive
* @param algorithm
* the archive algorithm
* @param absolutePath
* the destination ZIP file
* @param metaFiles
* the meta files
* @return
* a new instance of FileArchive
*/
public static FileArchive getInstance(Algorithm algorithm, String absolutePath, File... metaFiles) {
return getInstance(algorithm, new File(absolutePath), metaFiles);
}
/**
* Return an instance of FileArchive
* @param algorithm
* the archive algorithm
* @param zipFile
* the destination ZIP file
* @param metaFiles
* the meta files
* @return
* a new instance of FileArchive
*/
public static FileArchive getInstance(Algorithm algorithm, File zipFile, File... metaFiles) {
if (algorithm != null && zipFile != null && metaFiles != null)
return new FileArchive(algorithm, zipFile, metaFiles);
return null;
}
/**
* Register a new progress listener into the listeners linked list
* @param listener
* the ProgressListener instance
*/
public void registerProgressListener(ProgressListener listener) {
if (this.archive != null)
this.archive.registerProgressListener(listener);
}
/**
* Remove a progress listener from the listeners linked list
* @param listener
* the ProgressListener instance
*/
public void removeProgressListener(ProgressListener listener) {
if (this.archive != null)
this.archive.removeProgressListener(listener);
}
/**
* Start the archive task
*/
public synchronized void execute() {
new Thread(this).start();
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
public void run() {
if (this.archive != null)
this.archive.execute();
}
}
8. 核心测试代码
package org.file.util.archive;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.Properties;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JRadioButton;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
/**
* @author ALLEN
* <br/>Archive test case
*/
public class ArchiveTest extends JFrame implements ProgressListener {
private static final long serialVersionUID = -3707959572261992767L;
private static String path = null;
private static FileArchive fa;
private static ArchiveTest self;
private JLabel title;
private JProgressBar progress;
private JLabel label1;
private JLabel label2;
private JLabel label3;
private static ButtonGroup group;
private static JRadioButton button1;
private static JRadioButton button2;
private static JButton broswer;
private static JButton un_compress;
public ArchiveTest() {
super("JAVA SDK FILEARCHIVE");
self = this;
this.setIconImage(new ImageIcon(this.getClass().getResource("/org/data/resource/images/title.png")).getImage());
try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
} catch (Exception e) {
;
}
JPanel jPanel = new JPanel(null);
jPanel.setOpaque(true);
jPanel.setBackground(Color.ORANGE);
jPanel.setPreferredSize(new Dimension(330, 170));
this.title = new JLabel("*** JAVA SDK FILEARCHIVE 1.0.0.0 TESTCASE ***", JLabel.CENTER);
this.title.setBounds(new Rectangle(10, 3, 310, 25));
this.progress = new JProgressBar();
this.progress.setStringPainted(true);
this.progress.setValue(0);
this.progress.setString("Waiting for selecting ......");
this.progress.setBounds(new Rectangle(10, 25, 310, 25));
this.label1 = new JLabel("[ Size ] [ Time ]", JLabel.CENTER);
this.label1.setBounds(new Rectangle(10, 50, 310, 25));
this.label2 = new JLabel("[ Speed ] [ Remain ]", JLabel.CENTER);
this.label2.setBounds(new Rectangle(10, 70, 310, 25));
this.label3 = new JLabel("[ Count ] [ Compressed Ratio ]", JLabel.CENTER);
this.label3.setBounds(new Rectangle(10, 90, 310, 25));
group = new ButtonGroup();
button1 = new JRadioButton("Compress");
button1.setBounds(new Rectangle(60, 111, 100, 25));
button2 = new JRadioButton("UnCompress");
button2.setBounds(new Rectangle(180, 111, 100, 25));
broswer = new JButton("Broswer");
broswer.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JFileChooser chooser = new JFileChooser();
chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int returnVal = chooser.showOpenDialog(null);
if(returnVal == JFileChooser.APPROVE_OPTION) {
path = chooser.getSelectedFile().getAbsolutePath();
}
}
});
broswer.setBounds(new Rectangle(10, 136, 150, 25));
un_compress = new JButton("(Un) Compress");
un_compress.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (path != null) {
if (group.getSelection() == button1.getModel()) {
fa = FileArchive.getInstance(Algorithm.Compress, new File("FILEARCHIVE.ZIP"), path);
fa.registerProgressListener(self);
broswer.setEnabled(false);
un_compress.setEnabled(false);
fa.execute();
} else if (group.getSelection() == button2.getModel()) {
fa = FileArchive.getInstance(Algorithm.UnCompress, new File("FILEARCHIVE.ZIP"), path);
fa.registerProgressListener(self);
broswer.setEnabled(false);
un_compress.setEnabled(false);
fa.execute();
}
}
}
});
un_compress.setBounds(new Rectangle(168, 136, 150, 25));
jPanel.add(this.title);
jPanel.add(this.progress);
jPanel.add(this.label1);
jPanel.add(this.label2);
jPanel.add(this.label3);
group.add(button1);
group.add(button2);
group.setSelected(button1.getModel(), true);
jPanel.add(button1);
jPanel.add(button2);
jPanel.add(broswer);
jPanel.add(un_compress);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setContentPane(jPanel);
this.setSize(new Dimension(330, 170));
this.setResizable(false);
this.setVisible(true);
Dimension resolution = Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation((int)resolution.getWidth() / 2 - 165, (int)resolution.getHeight() / 2 - 133);
this.pack();
}
public void progress(long finished, long compressSize, long total, long start, long current, Properties properties) {
float percent = (float) finished * 100 / total;
long cost = current - start;
double speed = (double)finished * 0.9765625 / cost;
long remain = cost * (total - finished) / finished;
this.progress.setValue((int)percent);
this.progress.setString(String.format("%.2f%%", percent));
this.label1.setText(String.format("[ Size: %d Bytes ] [ Time: %d ms ]", total, cost));
this.label2.setText(String.format("[ Speed: %.2f Bps ] [ Remain: %d ms ]", speed, remain));
this.label3.setText(String.format("[ Count: %s ] [ Compressed Ratio: %.2f%% ]", properties.getProperty("Count"), (double)compressSize * 100 / total));
if (finished == total) {
broswer.setEnabled(true);
un_compress.setEnabled(true);
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
com.sun.awt.AWTUtilities.setWindowOpacity(new ArchiveTest(), 1.00f);
}
});
}
}