写一个对文件进行压缩和解压缩的程序，功能如下：

① 可以对纯英文文档实现压缩和解压；

② 较好的界面程序运行的说明。

 

 

介绍哈夫曼：



 



效率最高的判别树即为哈夫曼树

在计算机数据处理中，霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。

例如，在英文中，e的出现机率最高，而z的出现概率则最低。当利用霍夫曼编码对一篇英文进行压缩时，e极有可能用一个比特来表示，而z则可能花去25个比特（不是26）。用普通的表示方法时，每个英文字母均占用一个字节，即8个比特。二者相比，e使用了一般编码的1/8的长度，z则使用了3倍多。倘若我们能实现对于英文中各个字母出现概率的较准确的估算，就可以大幅度提高无损压缩的比例。

霍夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的路径长度是从树根到每一结点的路径长度之和，记为WPL=（W1*L1+W2*L2+W3*L3+...+Wn*Ln），N个权值Wi（i=1,2,...n）构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li（i=1,2,...n）。可以证明霍夫曼树的WPL是最小的。

 

文件压缩与解压

姓名：  范天祚 

1 程序说明

1.1数据结构

哈夫曼树

1.2函数功能说明

printfPercent界面

compress()读取文件内容并加以压缩，将压缩内容写入另一个文档

uncompress()解压缩文件，并将解压后的内容写入新文件

1.3 程序编写的思路及流程

压缩：统计字符出现次数、将节点按出现次数排序、构造哈夫曼树、设置字符编码、读文件字符、按设置好的编码替换字符、写入存储文件

解压：读取文件各参数、转换成二进制码、按码求对应字符、写入存储文件

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct head
{
    int b;						  //字符
    long count;                   //文件中该字符出现的次数
    long parent, lch, rch;        //make a tree
    char bits[256];               //the huffuman code
};

struct head header[512], tmp;  //节点树

void printfPercent(int per)
{
	int i = 0;
	printf("|");
	for(i = 0; i < 10; i++)
	{
		if(i < per/10)
			printf(">");
		else
			printf("-");
	}
	printf("|已完成%d%%\n",per);
}

//函数：compress()
//作用：读取文件内容并加以压缩
//将压缩内容写入另一个文档
int compress(const char *filename,const char *outputfile)
{
    char buf[512];
    unsigned char c;
    long i, j, m, n, f;
    long min1, pt1, flength;
    FILE *ifp, *ofp;
	int per = 10;
    ifp = fopen(filename, "rb");                  //打开原始文件
    if (ifp == NULL)
    {
        printf("打开文件失败:%s\n",filename);
        return 0;                             //如果打开失败，则输出错误信息
    }
    ofp = fopen(outputfile,"wb");                 //打开压缩后存储信息的文件
    if (ofp == NULL)
    {
        printf("打开文件失败:%s\n",outputfile);
        return 0;
    }
    flength = 0;
    while (!feof(ifp))
    {
        fread(&c, 1, 1, ifp);
        header[c].count ++;                       //读文件，统计字符出现次数
        flength ++;                               //记录文件的字符总数
    }
    flength --;
    header[c].count --;
    for (i = 0; i < 512; i ++)                    //HUFFMAN算法中初始节点的设置
    {
        if (header[i].count != 0)
            header[i].b = (unsigned char) i;
        else
            header[i].b = -1;
        header[i].parent = -1;
        header[i].lch = header[i].rch = -1;
    }

    for (i = 0; i < 256; i ++)                    //将节点按出现次数排序
    {
        for (j = i + 1; j < 256; j ++)
        {
            if (header[i].count < header[j].count)
            {
                tmp = header[i];
                header[i] = header[j];
                header[j] = tmp;
            }
        }
    }


    for (i = 0; i < 256; i ++)                    //统计不同字符的数量
	{
        if (header[i].count == 0)
            break;
	}

    n = i;
    m = 2 * n - 1;
    for (i = n; i < m; i ++)
    {
        min1 = 999999999;
        for (j = 0; j < i; j ++)
        {
            if (header[j].parent != -1) continue;
            if (min1 > header[j].count)
            {
                pt1 = j;
                min1 = header[j].count;
                continue;
            }
        }
        header[i].count = header[pt1].count;
        header[pt1].parent = i;
        header[i].lch = pt1;
        min1 = 999999999;
        for (j = 0; j < i; j ++)
        {
            if (header[j].parent != -1) continue;
            if (min1 > header[j].count)
            {
                pt1 = j;
                min1 = header[j].count;
                continue;
            }
        }
        header[i].count += header[pt1].count;
        header[i].rch = pt1;
        header[pt1].parent = i;
    }

    for (i = 0; i < n; i ++)                        //构造HUFFMAN树，设置字符的编码
    {
        f = i;
        header[i].bits[0] = 0;
        while (header[f].parent != -1)
        {
            j = f;
            f = header[f].parent;
            if (header[f].lch == j)
            {
                j = strlen(header[i].bits);
                memmove(header[i].bits + 1, header[i].bits, j + 1);
                header[i].bits[0] = '0';
            }
            else
            {
                j = strlen(header[i].bits);
                memmove(header[i].bits + 1, header[i].bits, j + 1);
                header[i].bits[0] = '1';
            }
        }
    }

    //下面的就是读原文件的每一个字符，按照设置好的编码替换文件中的字符
    fseek(ifp, 0, SEEK_SET);                                                //将指针定在文件起始位置
    fseek(ofp, 8, SEEK_SET);                                //以8位二进制数为单位进行读取
    buf[0] = 0;
    f = 0;
    pt1 = 8;

	printf("读取将要压缩的文件:%s\n",filename);
	printf("当前文件有:%d字符\n",flength);
	printf("正在压缩\n");

    while (!feof(ifp))
    {
        c = fgetc(ifp);
        f ++;
        for (i = 0; i < n; i ++)
        {
            if (c == header[i].b) break;
        }
        strcat(buf, header[i].bits);
        j = strlen(buf);
        c = 0;
        while (j >= 8)                                             //当剩余字符数量不小于8个时
        {
            for (i = 0; i < 8; i ++)                               //按照八位二进制数转化成十进制ASCII码写入文件一次进行压缩
            {
                if (buf[i] == '1') c = (c << 1) | 1;
                else c = c << 1;
            }
            fwrite(&c, 1, 1, ofp);
            pt1 ++;
            strcpy(buf, buf + 8);
            j = strlen(buf);
        }
		if(100 * f/flength > per)
		{
			printfPercent(per);
			per += 10;
		}
        if (f == flength)
			break;
    }
	printfPercent(100);

    if (j > 0)                                                      //当剩余字符数量少于8个时
    {
        strcat(buf, "00000000");
        for (i = 0; i < 8; i ++)
        {
            if (buf[i] == '1') c = (c << 1) | 1;
            else c = c << 1;                                        //对不足的位数进行补零
        }
        fwrite(&c, 1, 1, ofp);
        pt1 ++;
    }
    fseek(ofp, 0, SEEK_SET);                                        //将编码信息写入存储文件
	fwrite(&flength,1,sizeof(flength),ofp);
    fwrite(&pt1, sizeof(long), 1, ofp);
    fseek(ofp, pt1, SEEK_SET);
    fwrite(&n, sizeof(long), 1, ofp);
    for (i = 0; i < n; i ++)
    {
		tmp = header[i];

        fwrite(&(header[i].b), 1, 1, ofp);
		pt1++;
        c = strlen(header[i].bits);
        fwrite(&c, 1, 1, ofp);
		pt1++;
        j = strlen(header[i].bits);

        if (j % 8 != 0)                                             //当位数不满8时，对该数进行补零操作
        {
            for (f = j % 8; f < 8; f ++)
                strcat(header[i].bits, "0");
        }

        while (header[i].bits[0] != 0)
        {
            c = 0;
            for (j = 0; j < 8; j ++)
            {
                if (header[i].bits[j] == '1') c = (c << 1) | 1;
                else c = c << 1;
            }
            strcpy(header[i].bits, header[i].bits + 8);
            fwrite(&c, 1, 1, ofp);                                            //将所得的编码信息写入文件
			pt1++;
        }

		header[i] = tmp;
    }
    fclose(ifp);
    fclose(ofp);                                                              //关闭文件

	printf("压缩后文件为:%s\n",outputfile);
    printf("压缩后文件有:%d字符\n",pt1 + 4);

    return 1;                                       //返回压缩成功信息
}


//函数：uncompress()
//作用：解压缩文件，并将解压后的内容写入新文件
int uncompress(const char *filename,const char *outputfile)
{
    char buf[255], bx[255];
    unsigned char c;
	char out_filename[512];
    long i, j, m, n, f, p, l;
    long flength;
	int per = 10;
	int len = 0;
    FILE *ifp, *ofp;
	char c_name[512] = {0};
    ifp = fopen(filename, "rb");                                              //打开文件
    if (ifp == NULL)
    {
        return 0;     //若打开失败，则输出错误信息
    }

													  //读取原文件长
	if(outputfile)
		strcpy(out_filename,outputfile);
	else
		strcpy(out_filename,c_name);

    ofp = fopen(out_filename, "wb");                                            //打开文件
    if (ofp == NULL)
    {
        return 0;
    }

	fseek(ifp,0,SEEK_END);
	len = ftell(ifp);
	fseek(ifp,0,SEEK_SET);

	printf("将要读取解压的文件:%s\n",filename);
	printf("当前文件有:%d字符\n",len);
	printf("正在解压\n");

    fread(&flength, sizeof(long), 1, ifp);                                    //读取原文件长
    fread(&f, sizeof(long), 1, ifp);
    fseek(ifp, f, SEEK_SET);
    fread(&n, sizeof(long), 1, ifp);                                          //读取原文件各参数
    for (i = 0; i < n; i ++)                                                  //读取压缩文件内容并转换成二进制码
    {
        fread(&header[i].b, 1, 1, ifp);
        fread(&c, 1, 1, ifp);
        p = (long) c;
        header[i].count = p;
        header[i].bits[0] = 0;
        if (p % 8 > 0) m = p / 8 + 1;
        else m = p / 8;
        for (j = 0; j < m; j ++)
        {
            fread(&c, 1 , 1 , ifp);
            f = c;
            _itoa(f, buf, 2);
            f = strlen(buf);
            for (l = 8; l > f; l --)
            {
                strcat(header[i].bits, "0");                                  //位数不足，执行补零操作
            }
            strcat(header[i].bits, buf);
        }
        header[i].bits[p] = 0;
    }

    for (i = 0; i < n; i ++)
    {
        for (j = i + 1; j < n; j ++)
        {
            if (strlen(header[i].bits) > strlen(header[j].bits))
            {
                tmp = header[i];
                header[i] = header[j];
                header[j] = tmp;
            }
        }
    }

    p = strlen(header[n-1].bits);
    fseek(ifp, 8, SEEK_SET);
    m = 0;
    bx[0] = 0;


    while (1)
    {
        while (strlen(bx) < (unsigned int)p)
        {
            fread(&c, 1, 1, ifp);
            f = c;
            _itoa(f, buf, 2);
            f = strlen(buf);
            for (l = 8; l > f; l --)
            {
                strcat(bx, "0");
            }
            strcat(bx, buf);
        }
        for (i = 0; i < n; i ++)
        {
            if (memcmp(header[i].bits, bx, header[i].count) == 0) break;
        }
        strcpy(bx, bx + header[i].count);
        c = header[i].b;
        fwrite(&c, 1, 1, ofp);
        m ++;

		if(100 *  m/flength > per)
		{
			printfPercent(per);
			per += 10;
		}
        if (m == flength) break;
    }
	printfPercent(100);

    fclose(ifp);
    fclose(ofp);

	printf("解压后文件为:%s\n",out_filename);
    printf("解压后文件有:%d字符\n",flength);

    return 1;                   //输出成功信息
}

int main(int argc,const char *argv[])
{
	memset(&header,0,sizeof(header));
    memset(&tmp,0,sizeof(tmp));

	compress("测试文档.txt","测试文档.txt.zip");
	uncompress("测试文档.txt.zip","测试文档.txt 解压后.txt");
	system("pause");

	return 0;
}


 

2 功能展示

2.1 控制台显示



2.2 文件效果

开始时只有一个文件《测试文档.txt》：



打开《测试文档.txt》



《测试文档.txt》文件大小：



程序运行结束后多了两个文件：



以文本形式打开压缩二进制文件《测试文档.txt.zip》：



《测试文档.txt.zip》文件属性：

Java实现文件压缩与解压缩-----zip
1 基本概念
2 zip压缩
2.1 zip压缩代码实现
2.2 zip压缩代码改进
3 zip解压
3.1 zip不完美实现
3.2 zip解压完美实现
4 FileZip.class 实现.zip压缩与解压

Java中实现zip的压缩与解压缩
1 基本概念

ZipOutputStream 实现文件的压缩


ZipOutputStream (OutputStream out)  创建新的zip输出流
void putNextEntry(ZipEntry e)  开始写入新的zip文件条目并将流定位到条目数据的开始处

条目指的是一个文件夹下的多个文件。
ZipEntry(String name) 使用指定名称创建新的zip条目


ZipIutputStream实现文件的解压


ZipIutputStream (IutputStream out)  创建新的zip输入流
ZipEntry getNextEntry（）读取下一个zip条目并将流定位到该条目数据的开始处

2 zip压缩
2.1 zip压缩代码实现

程序完整代码

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class Uzip {
    /**
     * 压缩
     */

    public static void zip(String input, String output, String name) throws Exception {
    //要生成的压缩文件
        ZipOutputStream out = new ZipOutputStream(new FileOutputStream(output));
        String[] paths = input.split("\\|");
        File[] files = new File[paths.length];
        byte[] buffer = new byte[1024];
        for (int i = 0; i < paths.length; i++) {
            files[i] = new File(paths[i]);
        }
        for (int i = 0; i < files.length; i++) {
            FileInputStream fis = new FileInputStream(files[i]);
            if (files.length == 1 && name != null) {
                out.putNextEntry(new ZipEntry(name));
            } else {
                out.putNextEntry(new ZipEntry(files[i].getName()));
            }
            int len;
            // 读入需要下载的文件的内容，打包到zip文件
            while ((len = fis.read(buffer)) > 0) {
                out.write(buffer, 0, len);
            }
            out.closeEntry();
            fis.close();
        }
        out.close();
    }

    public static void main(String[ ] args){
        try {
            zip("E:\\Testzip\\test\\ytt.html","E:\\Test.zip","testytt");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


maven依赖：
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-compress</artifactId>
        <version>1.12</version>
    </dependency>


运行程序：


3.程序解读：

ZipEntry(String name) 只能实现一个固定条目的压缩，也就是你压缩什么就得写仔细它的路径，多个子文件压缩写法如下：

public static void main(String[ ] args){
        try {
            zip("E:\\Testzip\\test\\ytt.html|E:\\Testzip\\uugg.html","E:\\Test.zip",null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：
一定要写全E:\\Testzip\\test\\ytt.html，如果写E:\\Testzip\\test\\ytt会报错，报错信息无访问权限。
String input ：定义的是待压缩文件的条目。
String output：定义得到的压缩文件包.zip的名字。
String name：定义压缩后的条目的名字，如果与压缩前保持一致，定义name为null即可。
此程序无法实现对空文件夹的压缩。
2.2 zip压缩代码改进
改进的代码可以实现对任意文件的压缩，注意要写全文件类型，比如ytt.html，不允许省略.html。
import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * date: 2019/07/26
 * writed by yangtingting
 */
public class FileZip {
    /**
     * zip文件压缩
     * @param inputFile 待压缩文件夹/文件名
     * @param outputFile 生成的压缩包名字
     */

    public static void ZipCompress(String inputFile, String outputFile) throws Exception {
        //创建zip输出流
        ZipOutputStream out = new ZipOutputStream(new FileOutputStream(outputFile));
        //创建缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(out);
        File input = new File(inputFile);
        compress(out, bos, input,null);
        bos.close();
        out.close();
    }
    /**
     * @param name 压缩文件名，可以写为null保持默认
     */
    //递归压缩
    public static void compress(ZipOutputStream out, BufferedOutputStream bos, File input, String name) throws IOException {
        if (name == null) {
            name = input.getName();
        }
        //如果路径为目录（文件夹）
        if (input.isDirectory()) {
            //取出文件夹中的文件（或子文件夹）
            File[] flist = input.listFiles();

            if (flist.length == 0)//如果文件夹为空，则只需在目的地zip文件中写入一个目录进入
            {
                out.putNextEntry(new ZipEntry(name + "/"));
            } else//如果文件夹不为空，则递归调用compress，文件夹中的每一个文件（或文件夹）进行压缩
            {
                for (int i = 0; i < flist.length; i++) {
                    compress(out, bos, flist[i], name + "/" + flist[i].getName());
                }
            }
        } else//如果不是目录（文件夹），即为文件，则先写入目录进入点，之后将文件写入zip文件中
        {
            out.putNextEntry(new ZipEntry(name));
            FileInputStream fos = new FileInputStream(input);
            BufferedInputStream bis = new BufferedInputStream(fos);
            int len;
            //将源文件写入到zip文件中
            byte[] buf = new byte[1024];
            while ((len = bis.read(buf)) != -1) {
                bos.write(buf,0,len);
            }
            bis.close();
            fos.close();
        }
    }
    public static void main(String[] args) {
        try {
            ZipCompress("D:\\Test", "D:\\TestbyYTT.zip");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



3 zip解压
3.1 zip不完美实现

这个网上有很多代码的，比如：

package file;
 
import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
 
public class Decompressing {
    public static void main(String[] args) {
        File file = new File("E:\\hello.zip");//当前压缩文件
        ZipInputStream zin;//创建ZipInputStream对象
        try {
            ZipFile zipFile = new ZipFile(file);//创建压缩文件对象
            zin = new ZipInputStream(new FileInputStream(file));//实例化对象，指明要解压的文件
            ZipEntry entry ;
            while (((entry=zin.getNextEntry())!=null)&& !entry.isDirectory()){//如果entry不为空，并不在同一个目录下
                File tmp = new File(entry.getName());//解压出的文件路径
                if (!tmp.exists()){//如果文件不存在
                    tmp.getParentFile().mkdirs();//创建文件父类文件夹路径
                    OutputStream os = new FileOutputStream(tmp);//将文件目录中的文件放入输出流
                    //用输入流读取压缩文件中制定目录中的文件
                    InputStream in = zipFile.getInputStream(entry);
                    int count = 0;
                    while ((count = in.read())!=-1){//如有输入流可以读取到数值
                        os.write(count);//输出流写入
                    }
                    os.close();
                    in.close();
                }
                zin.closeEntry();
                System.out.println(entry.getName()+"解压成功");
            }
            zin.close();
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
}

以上代码运行时会抛出异常！！！！！！！！！
做出相应更改：
import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

/**
 * date:2019/7/26
 * writed by yangtingting
 */

public class zipUncompress {
    /**
     * zip文件解压
     *
     * @param inputFile   待解压文件夹/文件
     * @param destDirPath 解压路径
     */
    public static void zipUncompress(String inputFile, String destDirPath) throws Exception {
        File srcFile = new File(inputFile);//获取当前压缩文件
        // 判断源文件是否存在
        if (!srcFile.exists()) {
            throw new Exception(srcFile.getPath() + "所指文件不存在");
        }
        //开始解压
        //构建解压输入流
        ZipInputStream zIn = new ZipInputStream(new FileInputStream(srcFile));
        ZipEntry entry = null;
        File file = null;
        while ((entry = zIn.getNextEntry()) != null) {
            if (!entry.isDirectory()) {
                file = new File(destDirPath, entry.getName());
                if (!file.exists()) {
                    new File(file.getParent()).mkdirs();//创建此文件的上级目录
                }
                OutputStream out = new FileOutputStream(file);
                BufferedOutputStream bos = new BufferedOutputStream(out);
                int len = -1;
                byte[] buf = new byte[1024];
                while ((len = zIn.read(buf)) != -1) {
                    bos.write(buf, 0, len);
                }
                // 关流顺序，先打开的后关闭
                bos.close();
                out.close();
            }
        }
    }
    public static void main(String[] args) {
        try {
            zipUncompress("D:\\ytt.zip", "D:\\ytt的解压文件\\");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

完美运行！！！
3.2 zip解压完美实现
改进后的代码：
import java.io.*;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

/**
 * date:2019/7/26
 * writed by yangtingting
 */

public class zipUncompress {
    /**
     * zip文件解压
     * @param inputFile  待解压文件夹/文件
     * @param destDirPath  解压路径
     */
    public static void zipUncompress(String inputFile,String destDirPath) throws Exception {
        File srcFile = new File(inputFile);//获取当前压缩文件
        // 判断源文件是否存在
        if (!srcFile.exists()) {
            throw new Exception(srcFile.getPath() + "所指文件不存在");
        }
        ZipFile zipFile = new ZipFile(srcFile);//创建压缩文件对象
        //开始解压
        Enumeration<?> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry entry = (ZipEntry) entries.nextElement();
            // 如果是文件夹，就创建个文件夹
            if (entry.isDirectory()) {
                String dirPath = destDirPath + "/" + entry.getName();
                srcFile.mkdirs();
            } else {
                // 如果是文件，就先创建一个文件，然后用io流把内容copy过去
                File targetFile = new File(destDirPath + "/" + entry.getName());
                // 保证这个文件的父文件夹必须要存在
                if (!targetFile.getParentFile().exists()) {
                    targetFile.getParentFile().mkdirs();
                }
                targetFile.createNewFile();
                // 将压缩文件内容写入到这个文件中
                InputStream is = zipFile.getInputStream(entry);
                FileOutputStream fos = new FileOutputStream(targetFile);
                int len;
                byte[] buf = new byte[1024];
                while ((len = is.read(buf)) != -1) {
                    fos.write(buf, 0, len);
                }
                // 关流顺序，先打开的后关闭
                fos.close();
                is.close();
            }
        }
    }
    public static void main(String[] args) {
        try {
            zipUncompress("D:\\ytt.zip","D:\\ytt的解压文件");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


4 FileZip.class 实现.zip压缩与解压
完整代码：
import java.io.*;
import java.util.zip.*;
import java.util.zip.ZipEntry;

/**
 * date: 2019/07/26
 * writed by yangtingting
 */
public class FileZip {
    /**
     * zip文件压缩
     * @param inputFile 待压缩文件夹/文件名
     * @param outputFile 生成的压缩包名字
     */

    public static void ZipCompress(String inputFile, String outputFile) throws Exception {
        //创建zip输出流
        ZipOutputStream out = new ZipOutputStream(new FileOutputStream(outputFile));
        //创建缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(out);
        File input = new File(inputFile);
        compress(out, bos, input,null);
        bos.close();
        out.close();
    }
    /**
     * @param name 压缩文件名，可以写为null保持默认
     */
    //递归压缩
    public static void compress(ZipOutputStream out, BufferedOutputStream bos, File input, String name) throws IOException {
        if (name == null) {
            name = input.getName();
        }
        //如果路径为目录（文件夹）
        if (input.isDirectory()) {
            //取出文件夹中的文件（或子文件夹）
            File[] flist = input.listFiles();

            if (flist.length == 0)//如果文件夹为空，则只需在目的地zip文件中写入一个目录进入
            {
                out.putNextEntry(new ZipEntry(name + "/"));
            } else//如果文件夹不为空，则递归调用compress，文件夹中的每一个文件（或文件夹）进行压缩
            {
                for (int i = 0; i < flist.length; i++) {
                    compress(out, bos, flist[i], name + "/" + flist[i].getName());
                }
            }
        } else//如果不是目录（文件夹），即为文件，则先写入目录进入点，之后将文件写入zip文件中
        {
            out.putNextEntry(new ZipEntry(name));
            FileInputStream fos = new FileInputStream(input);
            BufferedInputStream bis = new BufferedInputStream(fos);
            int len=-1;
            //将源文件写入到zip文件中
            byte[] buf = new byte[1024];
            while ((len = bis.read(buf)) != -1) {
                bos.write(buf,0,len);
            }
            bis.close();
            fos.close();
        }
    }

    /**
     * zip解压
     * @param inputFile 待解压文件名
     * @param destDirPath  解压路径
     */

    public static void ZipUncompress(String inputFile,String destDirPath) throws Exception {
        File srcFile = new File(inputFile);//获取当前压缩文件
        // 判断源文件是否存在
        if (!srcFile.exists()) {
            throw new Exception(srcFile.getPath() + "所指文件不存在");
        }
        //开始解压
        //构建解压输入流
        ZipInputStream zIn = new ZipInputStream(new FileInputStream(srcFile));
        ZipEntry entry = null;
        File file = null;
        while ((entry = zIn.getNextEntry()) != null) {
            if (!entry.isDirectory()) {
                file = new File(destDirPath, entry.getName());
                if (!file.exists()) {
                    new File(file.getParent()).mkdirs();//创建此文件的上级目录
                }
                OutputStream out = new FileOutputStream(file);
                BufferedOutputStream bos = new BufferedOutputStream(out);
                int len = -1;
                byte[] buf = new byte[1024];
                while ((len = zIn.read(buf)) != -1) {
                    bos.write(buf, 0, len);
                }
                // 关流顺序，先打开的后关闭
                bos.close();
                out.close();
            }
        }
    }


    public static void main(String[] args) {
        try {
            ZipCompress("D:\\Test", "D:\\TestbyYTT.zip");
            ZipUncompress("D:\\ytt.zip","D:\\ytt的解压文件");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

java使用ant实现Zip文件压缩、解压缩Zip文件。
单个文件压缩成Zip文件，多个文件压缩成Zip文件。
可以压缩大文件。

需要使用到ant.jar文件，放到lib目录下。
ant.jar下载：http://download.csdn.net/detail/xinxin19881112/8906157


Zip.java


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.zip.ZipOutputStream;
import org.apache.tools.zip.ZipEntry;

/**
 * ZIP操作工具类
 */
public class Zip {
	
	/**
	 * 压缩文件列表到某ZIP文件
	 * @param zipFilename 要压缩到的ZIP文件
	 * @param paths 文件列表，多参数
	 * @throws Exception
	 */
	public static void compress(String zipFilename, String... paths)
			throws Exception {
		compress(new FileOutputStream(zipFilename), paths);
	}

	/**
	 * 压缩文件列表到输出流
	 * @param os 要压缩到的流
	 * @param paths 文件列表，多参数
	 * @throws Exception
	 */
	public static void compress(OutputStream os, String... paths)
			throws Exception {
		ZipOutputStream zos = new ZipOutputStream(os);
		for (String path : paths) {
			if (path.equals(""))
				continue;
			java.io.File file = new java.io.File(path);
			if (file.exists()) {
				if (file.isDirectory()) {
					zipDirectory(zos, file.getPath(), file.getName()
							+ File.separator);
				} else {
					zipFile(zos, file.getPath(), "");
				}
			}
		}
		zos.close();
	}
	
	private static void zipDirectory(ZipOutputStream zos, String dirName,
			String basePath) throws Exception {
		File dir = new File(dirName);
		if (dir.exists()) {
			File files[] = dir.listFiles();
			if (files.length > 0) {
				for (File file : files) {
					if (file.isDirectory()) {
						zipDirectory(zos, file.getPath(), basePath
								+ file.getName().substring(
										file.getName().lastIndexOf(
												File.separator) + 1)
								+ File.separator);
					} else
						zipFile(zos, file.getPath(), basePath);
				}
			} else {
				ZipEntry ze = new ZipEntry(basePath);
				zos.putNextEntry(ze);
			}
		}
	}

	private static void zipFile(ZipOutputStream zos, String filename,
			String basePath) throws Exception {
		File file = new File(filename);
		if (file.exists()) {
			FileInputStream fis = new FileInputStream(filename);
			ZipEntry ze = new ZipEntry(basePath + file.getName());
			zos.putNextEntry(ze);
			byte[] buffer = new byte[8192];
			int count = 0;
			while ((count = fis.read(buffer)) > 0) {
				zos.write(buffer, 0, count);
			}
			fis.close();
		}
	}
}





TestCompress.java


import java.io.FileOutputStream;

import com.xx.commmon.Zip;

/**
 * 压缩文件测试
 */
public class TestCompress {

	public static void main(String[] args) {
		// 要压缩的文件列表
		String path01 = "E:\\下载\\cn_windows_8_x86_dvd_915414.iso";
		String path02 = "e:\\PPT模版_V0.1.potx";
		try {
			FileOutputStream os = new FileOutputStream("e:\\测试.zip"); // 输出的ZIP文件流
			Zip.compress(os, path01);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}





TestEctractZip.java


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

/**
 * 解压缩测试
 */
public class TestEctractZip {

	@SuppressWarnings( { "unchecked", "static-access" })
	public static void main(String[] args) {
		TestEctractZip z = new TestEctractZip();
		ArrayList<String> a = z.Ectract("C:\\a.zip", "C:\\tmp\\"); // 返回解压缩出来的文件列表
		for(String s : a){
			System.out.println(s);
		}
	}

	/**
	 * 解压缩
	 * @param sZipPathFile 要解压的文件
	 * @param sDestPath 解压到某文件夹
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static ArrayList Ectract(String sZipPathFile, String sDestPath) {
		ArrayList<String> allFileName = new ArrayList<String>();
		try {
			// 先指定压缩档的位置和档名，建立FileInputStream对象
			FileInputStream fins = new FileInputStream(sZipPathFile);
			// 将fins传入ZipInputStream中
			ZipInputStream zins = new ZipInputStream(fins);
			ZipEntry ze = null;
			byte[] ch = new byte[256];
			while ((ze = zins.getNextEntry()) != null) {
				File zfile = new File(sDestPath + ze.getName());
				//File zfile = new File(sDestPath +File.separator+ ze.getName());
				File fpath = new File(zfile.getParentFile().getPath());
				if (ze.isDirectory()) {
					if (!zfile.exists())
						zfile.mkdirs();
					zins.closeEntry();
				} else {
					if (!fpath.exists())
						fpath.mkdirs();
					FileOutputStream fouts = new FileOutputStream(zfile);
					int i;
					allFileName.add(zfile.getAbsolutePath());
					while ((i = zins.read(ch)) != -1)
						fouts.write(ch, 0, i);
					zins.closeEntry();
					fouts.close();
				}
			}
			fins.close();
			zins.close();
		} catch (Exception e) {
			System.err.println("Extract error:" + e.getMessage());
		}
		return allFileName;
	}
}


新新：http://blog.csdn.net/xinxin19881112/article/details/46913931

 Java小程序之哈夫曼树与文件压缩和解压缩（二）文件压缩篇


一、初识压缩与解压缩原理


压缩可以理解为：对文件的加密过程

解压可以理解为：对文件的解密过程
例如：
我  - a
是  -  b
谁  -  c
我是谁   -》  abc


二、压缩原理详解
我们都知道，计算机只能存储二进制数据，即计算机中存储的都是0和1；那么我们看的的a、b、c等英文字母和汉字在计算机中使怎么存储的呢？
这就涉及到了编码的问题了，英文用的编码是ASCII，即利用一个字节（8位，也就是8个0和1 组成的01串）来表示各种英文字母以及符号，例如a字母在ASCII编码中是97（十进制），在计算机中的存储是：01100001；所以一个英文字母或者符号只占一个字节；因为汉字众多，远远不止256个，所以汉字的编码需要用两个字节来编码，总共可编码2*16个汉字；所以一个汉字一半占两个字节；常用的汉字编码有UTF-8和GBK等；


现在比如在一个文件中存储有abaabc；那么计算机中存储的应该是01100001（a） 01100010 （b）01100001（a）01100001（a）01100010
 （b）01100011 （c），一共占6个字节；如何利用哈夫曼树将这个文件进行压缩呢？构造哈夫曼树，首先的有权值，那么拿什么东西作为权值呢？


我们用文件中某个字出现的次数作为权值来构造哈夫曼树，上面的字符串中a出现了三次，那么把3作为a的权值，b出现了两次，那么把2作为b的权值，同理把1作为c的权值，那么我们得到的哈夫曼树如下图：










 aabbac ==》01100001  01100010 01100001 01100001 01100010 01100011
那么原来的那一串abaabc用哈夫曼编码后为：aabbac ==》1 1 01 1 1 01 00
瞧，原来的6个字节现在变成了2个字节了；我们只要把这个新的01串转成十进制整数，再把这个十进制的整数写入到压缩文件中即完成了压缩；



     

三、压缩具体实现思路：

1、读取文件，统计文件中每个字节出现次数（作为构造哈夫曼树的权值）
2、根据次数构建哈夫曼树
3、根据哈夫曼树构建码表
4、再读取文件，通过码表对文件中读取的字节进行加密处理



难点分析：
定义一个256长度的整型数组
定义一个256长度的字符串数组
为什么呢？其一、英文字母和符号加起来正好256个，当读到是97时，正好可以在该位置加1
后面的代码会体现，这里还需要注意的是索引要对应好，比如a在ASCII码中是97，那么，字符串数组索引为97的位置存储的一定要是a字母对应的哈夫曼编码






  
通过哈夫曼压缩后，我们将得到一串压缩后01串，最后，我们需要把这一01串每8个一组，转换长十进制的整数，最后不够8位的补0，把得到的十进制整数写入文件即完成压缩工作了！



四、哈夫曼树文件压缩源代码：
哈夫曼节点类：这里需要索引的目通过索引既可以得到该索引的哈夫曼编码，同时可以得打原来的数据

package com.huaxin.compress;


/*
 * 哈夫曼节点类
 */
public class HuffmNode {
	//数据域
	private int data;
	//索引
	private int index;
	//左子节点
	private HuffmNode left;
	//右子节点
	private HuffmNode right;
	
	//哈夫曼节点的构造函数
	public HuffmNode(int data,int index){
		this.data=data;
		this.index=index;
	}
	
	//私有属性的封装
	public int getData() {
		return data;
	}
	public void setData(int data) {
		this.data = data;
	}
	public int getIndex() {
		return index;
	}
	public void setIndex(int index) {
		this.index = index;
	}
	public HuffmNode getLeft() {
		return left;
	}
	public void setLeft(HuffmNode left) {
		this.left = left;
	}
	public HuffmNode getRight() {
		return right;
	}
	public void setRight(HuffmNode right) {
		this.right = right;
	}

}




压缩以及压缩实现类
package com.huaxin.compress;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.LinkedList;

public class Compress {
	
	public int [] times = new int[256];
	public String [] HuffmCodes=new String[256];
	public LinkedList<HuffmNode> list = new LinkedList<HuffmNode>();
	//统计次数
	
	//初始化
	public Compress(){
		for (int i = 0; i < HuffmCodes.length; i++) {
			HuffmCodes[i]="";
		}
	}
	
	public void countTimes(String path) throws Exception{
		//构造文件输入流
		FileInputStream fis = new FileInputStream(path);
		//读取文件
		int value=fis.read();
		while(value!=-1){
			times[value]++;
			value=fis.read();
		}
		//关闭流
		fis.close();
	}
	
	//构造哈夫曼树
	public HuffmNode createTree(){
		//将次数作为权值构造森林
		for (int i = 0; i < times.length; i++) {
			if(times[i]!=0){
				HuffmNode node = new HuffmNode(times[i],i);
				//将构造好的节点加入到容器中的正确位置
				list.add(getIndex(node), node);
			}
		}
		
		//将森林（容器中的各个节点）构造成哈夫曼树
		while(list.size()>1) {
			//获取容器中第一个元素（权值最小的节点）
			HuffmNode firstNode =list.removeFirst();
			//获取中新的第一个元素，原来的第一个元素已经被移除了（权值次小的节点）
			HuffmNode secondNode =list.removeFirst();
			//将权值最小的两个节点构造成父节点
			HuffmNode fatherNode =
					new HuffmNode(firstNode.getData()+secondNode.getData(),-1);
			fatherNode.setLeft(firstNode);
			fatherNode.setRight(secondNode);
			//父节点加入到容器中的正确位置
			list.add(getIndex(fatherNode),fatherNode);
		}
		//返回整颗树的根节点
		return list.getFirst();
	}
	//利用前序遍历获取编码表
	public void getHuffmCode(HuffmNode root,String code){
		//往左走，哈夫曼编码加0
		if(root.getLeft()!=null){
			getHuffmCode(root.getLeft(),code+"0");
		}
		//往右走，哈夫曼编码加1
		if(root.getRight()!=null){
			getHuffmCode(root.getRight(),code+"1");
		}
		//如果是叶子节点，返回该叶子节点的哈夫曼编码
		if(root.getLeft()==null && root.getRight()==null){
//			System.out.println(root.getIndex()+"的编码为："+code);
			HuffmCodes[root.getIndex()]=code;
		}
	}
	
	//压缩文件
	public void compress(String path,String destpath) throws Exception{
		
		
		
		//构建文件输出流
		FileOutputStream fos = new FileOutputStream(destpath);
		FileInputStream fis = new FileInputStream(path);
		
		/**===============将数据写入到文件中================*/
		
		//读文件，并将对应的哈夫曼编码串接成字符串
		int value=fis.read();
		String str = "";
		while(value!=-1){
			str+=HuffmCodes[value];
//			System.out.println((char)value+":"+str);
			value=fis.read();
		}
		System.out.println(str);
		fis.close();
		
			String s="";
			while(str.length()>=8){
				s=str.substring(0, 8);
				int b=changeStringToInt(s);
//				System.out.println(c);
				fos.write(b);
				fos.flush();
				str=str.substring(8);
			}
			
			int last1=8-str.length();
			for (int i = 0; i <last1; i++) {
				str+="0";
			}
			s=str.substring(0, 8);
//			System.out.println(s);
			int d=changeStringToInt(s);
			fos.write(d);
			
//			补0的个数暂时不写，后面解压缩在写
//			fos.write(last1);
//			fos.flush();
			
			fos.close();
	
	}
	
	//插入元素位置的索引
	public int getIndex(HuffmNode node) {
		for (int i = 0; i < list.size(); i++) {
			if(node.getData()<=list.get(i).getData()){
				return i;
			}
		}
       return list.size();
	}
	
	//将字符串转换成整数
	public int changeStringToInt(String s){
		int v1=(s.charAt(0)-48)*128;
		int v2=(s.charAt(1)-48)*64;
		int v3=(s.charAt(2)-48)*32;
		int v4=(s.charAt(3)-48)*16;
		int v5=(s.charAt(4)-48)*8;
		int v6=(s.charAt(5)-48)*4;
		int v7=(s.charAt(6)-48)*2;
		int v8=(s.charAt(7)-48)*1;
		return v1+v2+v3+v4+v5+v6+v7+v8;
			
	}	
	
}


测试类：

package com.huaxin.compress;

public class Test {
	public static void main(String[] args) throws Exception {
		//创建压缩对象
		Compress compress = new Compress();
		//统计文件中0-255出现的次数
		compress.countTimes("C:\\Users\\Administrator\\Desktop\\test.txt");
		//构造哈夫曼树，并得到根节点
		HuffmNode root=compress.createTree();
		//得到哈夫曼编码
		compress.getHuffmCode(root, "");
		//压缩文件
		compress.compress("C:\\Users\\Administrator\\Desktop\\test.txt",
				"C:\\Users\\Administrator\\Desktop\\test.zip");
		
	}

}



运行结果：（.zip不能用WRAR打开，只是显示图标和.zip文件是一样的；.zip文件用的其他压缩方法）




五、总结：
1、明白了压缩的基本原理
2、知道如何利用哈夫曼树进行文件压缩
3、对对应索引位置的理解；