精华内容
下载资源
问答
  • 哈夫曼实现文件压缩解压缩(c语言)

    万次阅读 多人点赞 2019-01-23 17:04:47
    写一个对文件进行压缩和解压缩的程序,功能如下: ① 可以对纯英文文档实现压缩和解压; ② 较好的界面程序运行的说明。 介绍哈夫曼: 效率最高的判别树即为哈夫曼树 在计算机数据处理中,霍夫曼编码...

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

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

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

     

     

    介绍哈夫曼:

     

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

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

    例如,在英文中,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文件压缩与解压缩--附完整代码

    万次阅读 多人点赞 2019-07-26 14:54:09
    Java实现文件压缩与解压缩-----zip、.7z1. 基本概念1.1 Java中实现zip的压缩与解压缩1.1.1 基本概念1.1.2 zip压缩代码实现1.3 zip压缩代码改进 1. 基本概念 1.1 Java中实现zip的压缩与解压缩 1.1.1 基本概念 ...

    Java中实现zip的压缩与解压缩

    1 基本概念

    1. ZipOutputStream 实现文件的压缩
    • ZipOutputStream (OutputStream out) 创建新的zip输出流
    • void putNextEntry(ZipEntry e) 开始写入新的zip文件条目并将流定位到条目数据的开始处
      条目指的是一个文件夹下的多个文件。
    • ZipEntry(String name) 使用指定名称创建新的zip条目
    1. ZipIutputStream实现文件的解压
    • ZipIutputStream (IutputStream out) 创建新的zip输入流
    • ZipEntry getNextEntry()读取下一个zip条目并将流定位到该条目数据的开始处

    2 zip压缩

    2.1 zip压缩代码实现

    1. 程序完整代码
    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>
    
    1. 运行程序:

    在这里插入图片描述

    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不完美实现

    1. 这个网上有很多代码的,比如:
    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实现大文件压缩

    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 二...

     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 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、对对应索引位置的理解;


    展开全文
  • Java 多文件加密压缩 添加文件加密压缩工具包依赖 <!-- zip4j压缩工具 --> <dependency> <groupId>net.lingala.zip4j</groupId> <artifactId>zip4j</artifactId> <...
  • Linux文件压缩解压命令

    万次阅读 2019-05-29 20:27:58
    Linux文件压缩解压命令 tar功能:文件压缩解压 格式:tar 参数 压缩后的文件名 被压缩的文件名 tar 参数 被解压的文件名 -C 指定目录 (如果省略 -C 指定目录,则解压到当前文件夹) -c 建立一个压缩文件的参数...
  • 文件下载 //下载单个文件 public void downloadFile(HttpServletResponse response){ String path = "D:\test\ce\1.txt" File file = new File(path); if(file.exists()){ String fil...
  • spark & 文件压缩

    千次阅读 2016-07-22 10:41:58
    hdfs中存储的文件一般都是多副本存储,对...文本文件压缩snappyjson文本压缩率 38.2%,压缩和解压缩时间短。import org.apache.parquet.hadoop.codec.SnappyCodec rdd.saveAsTextFile("codec/snappy",classOf[SnappyCod
  • 我们可以用它们进行zip文件压缩和解压缩。 代码 package util; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOu...
  • 完成文件压缩与解压缩花了近一个星期的时间,期间,花了很遇到不少问题,花了很长时间去调试,最后完成了文本文件的压缩。通过调用库中的优先级队列实现哈夫曼树,基于哈夫曼树最终实现文件压缩。 ## 实现哈夫曼树...
  • Linux 基础命令入门 文件压缩

    千次阅读 2020-05-06 13:07:34
    Linux 基础命令入门(三) 1、创建一个文件,并将其...第二步骤,把打成包的文件压缩,testtar.txt.tar.gz 创建一个目录”test”;mkdir test 创建一个文件”testtar.txt”; touch testtar.txt 将testtar.txt打包,...
  • Linux 系统下文件压缩&解压

    万次阅读 2020-06-01 10:51:05
    压缩永远是针对于一个独立文件进行的,一个文件夹(某目录下文件)想要进行压缩首先要进行打包,打包成一个文件,所以在 Windows 下常说的压缩是打包与压缩的总称,同理解压是指解压缩与拆包的宗盛。很多命令也将...
  • tar命令 可以用来压缩打包单文件...多个文件压缩打包 tar czvf my.tar.gz file1 file2,...(file*)(也可以给file*文件mv 目录在压缩) 单个目录压缩打包 tar czvf my.tar.gz dir1 多个目录压缩打包 tar czvf my.t
  • SQLServer数据库文件压缩

    千次阅读 2019-05-06 13:48:34
    1.数据库文件压缩 点击数据库表右键-->任务-->收缩-->数据库 2.数据库日志文件压缩 --设置为简单模式 ALTER DATABASE 数据库名SET RECOVERY SIMPLE; GO -- 将日志文件压缩到1 MB. 数据库日志...
  • Java多文件压缩下载解决方案

    千次阅读 2018-09-07 18:00:33
    Java多文件压缩下载解决方案 需求: 会员运营平台经过改版后页面增加了许多全部下载链接,上周上线比较仓促,全部下载是一个直接下载ZIP压缩文件的链接,每个ZIP压缩文件都是由公司运营人员将页面需要下载的文件...
  • Linux文件压缩和打包

    万次阅读 2018-05-27 13:47:04
    Linux文件压缩和打包一、压缩打包介绍常见压缩文件​ ~Windows .rar .7z .zip ​ ~Linux .zip .gz .bz2 .xz .tar.gz .tar.bz2 .tar.xz文件压缩的作用:1、节省空间​ ...
  • java Zip文件压缩含加密

    千次阅读 2019-02-20 08:54:20
    以下是对文件压缩的方法,这里只是单个文件压缩,多个变通一下就可以。 首先下载一个jar包:zip4j-1.3.2.jar /** * 对压缩文件进行加密 */ public void ZipFileAndEncrypt(String filePath,String ...
  • ubuntu下文件压缩/解压缩命令总结

    千次阅读 2018-09-16 21:33:09
    ubuntu下文件压缩/解压缩命令总结 http://blog.csdn.net/luo86106/article/details/6...
  • 本文简单介绍了WinRAR如何把一个文件压缩成几个固定大小的文件以及如何解压这几个文件。 1、压缩 1 > 鼠标选中待压缩文件-右键-添加到压缩文件。 2 > 在弹出的“压缩文件和参数”窗口-切分压缩分卷...
  • 哈夫曼树实现文件压缩与解压缩

    万次阅读 热门讨论 2016-06-06 21:23:14
    见识了360压缩的神奇后,想要实现自己的文件压缩程序,然后花了近一个星期的时间去完成文件压缩与解压缩,期间有很多坑,花了很长时间去调试它,最后把坑给填了(真心的感受到了程序员写代码时的小小粗心会把自己给...
  • tar命令可以用来压缩打包单文件...常用格式:单个文件压缩打包 tar czvf my.tar.gz file1多个文件压缩打包 tar czvf my.tar.gz file1 file2,...(file*)(也可以给file*文件mv 目录在压缩)单个目录压缩打包 tar c...
  • Gulp——文件压缩和文件指纹

    千次阅读 2016-07-31 16:27:15
    上周还倒腾了一件事,就是使用gulp给项目的JS和CSS添加版本,主要是控制新版本文件发布时浏览器...首先介绍下gulp的文件压缩(压缩css和js) 我的文件目录如下: (标红部分是生成的处理后的文件) 如何使用gulp,
  • Huffman的应用之文件压缩与解压缩

    千次阅读 2016-10-30 12:02:28
    文件压缩与解压缩>  最近这段时间一直在学习树的这种数据结构,也接触到了Huffman树以及了解了什仫是Huffman编码,而我们常用的zip压缩也是利用的Huffman编码的特性,那仫是不是可以自己实现一个文件压缩呢?当然可以...
  • Java实现zip文件压缩(单个文件、文件夹以及文件和文件夹的组合压缩) package com.ljheee.ziptool.core; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io...
  • Android zip文件压缩与解压

    万次阅读 2019-03-19 19:50:57
    Android zip文件压缩与解压 Android开发中偶尔需要用到zip文件的压缩与解压,正好公司项目需要用到,趁此机会特意总结了下,分享给大家,也是对我学习Android的记录。 zip压缩 Android中的zip压缩主要用到两个类:...
  • linux文件压缩和压缩常用命令小结

    千次阅读 2016-10-11 13:29:51
    文件压缩和常用命令 zip是目前使用最多的文档压缩格式。可以跨平台使用,在linux,windows和mac os上均可使用,但是支持的压缩率不是很高。 rar虽然普及率和速度上比zip略差一些,但是rar有更好的压缩率,支持多卷...
  • 用C++实现文件压缩

    万次阅读 多人点赞 2016-08-15 00:28:43
    乍一听,这个文件压缩的名字貌似是很高大上的,其实,在数据结构中学完Huffman树之后,就可以理解这个东西其实不是那么的高不可攀。 文件压缩 所谓文件压缩,其实就是将对应的字符编码转换为另一种占据字节数少的...
  • java多个文件压缩成zip文件

    千次阅读 2018-08-15 14:14:05
     文件压缩 */ private static void ZipFiles(java.io.File[] srcfile, java.io.File zipfile) { byte[] buf=new byte[1024]; ZipOutputStream out=null; try { out=new ZipOutputStream(new Fi...
  • 基于哈夫曼编码的文本文件压缩与解压缩

    万次阅读 多人点赞 2017-10-30 13:47:47
    基于哈夫曼编码实现文件压缩与解压缩,采用哈夫曼静态编码的方式,通过对数据进行两遍扫描,第一次统计出现的字符频次,进而构造哈夫曼树,第二遍扫描数据根据得到的哈夫曼树对数据进行编码。对于其中的加密编码只是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 147,759
精华内容 59,103
关键字:

文件压缩