#一、gzip压缩技术

gzip(GNU- ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用户浏览页面的时候速度会快得多。gzip的压缩页面需要浏览器和服务器双方都支持，实际上就是服务器端压缩，传到浏览器后浏览器解压并解析。浏览器那里不需要我们担心，因为目前的大多数浏览器都支持解析gzip压缩过的资源文件。在实际的应用中我们发现压缩的比率往往在3到10倍，也就是本来50k大小的页面，采用压缩后实际传输的内容大小只有5至15k大小，这可以大大节省服务器的网络带宽，同时如果应用程序的响应足够快时，网站的速度瓶颈就转到了网络的传输速度上，因此内容压缩后就可以大大的提升页面的浏览速度。

实现gzip压缩的方式有多种，比如：nginx、tomcat、java等，选用其中一种即可。

#二、nginx启用gzip

Nginx的压缩输出有一组gzip压缩指令来实现。相关指令位于http{….}两个大括号之间，如下：
  #打开gzip压缩
  gzip on;
  #不压缩临界值，大于1K的才压缩，一般不用改
  gzip_min_length 1k;
  #设置系统获取几个单位的缓存用于存储gzip的压缩结果数据流，这里设置以16k为单位的4倍申请内存
  gzip_buffers 4 16k;
  #默认为http 1.1，现在99.99%的浏览器基本上都支持gzip解压了，所有无需设置此项
  #gzip_http_version 1.0;
  #gzip压缩比，1 最小处理速度最快，9 最大但处理最慢（传输快但比较消耗cpu）
  gzip_comp_level 2;
  #要压缩的文件类型，注意"text/html"类型无论是否指定总是会被压缩的
  gzip_types text/plain application/x-javascript text/css application/xml text/javascript application/javascript application/x-httpd-php image/jpeg image/gif image/png;
  #on的话会在Header里增加"Vary: Accept-Encoding"，给代理服务器用的，有的浏览器支持压缩，有的不支持，所以避免浪费不支持的也压缩，所以根据客户端的HTTP头来判断，是否需要压缩
  #我这里的浏览器肯定支持gzip压缩，所以就不开启此功能了
  gzip_vary off;
  #IE6对Gzip不怎么友好，不给它Gzip压缩了
  gzip_disable "MSIE [1-6]\.";

#三、tomcat启用gzip

目前大多数主流WEB中间件都支持GZIP压缩、下面以Tomcat 为例进行说明：

找到Tomcat 目录下的conf下的server.xml，并找到如下信息：
      <Connector port = "8080" maxHttpHeaderSize = "8192" maxThreads = "150" minSpareThreads = "25"
              maxSpareThreads = "75" enableLookups = "false" redirectPort = "8443" acceptCount = "100"
              connectionTimeout = "20000" disableUploadTimeout = "true"
      将它改成如下的形式（其实在上面代码的下面已经有了，将他们打开而已。）：
      <Connector port="8080" maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25"
             maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100"
             connectionTimeout="20000" disableUploadTimeout="true"
             compression="on" compressionMinSize="2048" noCompressionUserAgents="gozilla, traviata"
             compressableMimeType="text/html,text/xml" >
      这样，就能够对html和xml进行压缩了，如果要压缩css 和 js，那么需要将
           compressableMimeType=”text/html,text/xml”加入css和js：
           <Connector port="8080" ......... compressableMimeType="text/html,text/xml,text/css,text/javascript" >

一般文本类型的静态文件可以通过这种方式压缩后传输、提高传输效率。

#四、java服务器启用gzip

java本身可以通过过滤器filter实现gzip压缩。下面提供一个gzip工具类：
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class GZIPUtils  {
    public static final String GZIP_ENCODE_UTF_8 = "UTF-8"; 
    public static final String GZIP_ENCODE_ISO_8859_1 = "ISO-8859-1";

    
    public static byte[] compress(String str, String encoding) {
        if (str == null || str.length() == 0) {
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        GZIPOutputStream gzip;
        try {
            gzip = new GZIPOutputStream(out);
            gzip.write(str.getBytes(encoding));
            gzip.close();
        } catch ( Exception e) {
            e.printStackTrace();
        }
        return out.toByteArray();
    }
    
    public static byte[] compress(String str) throws IOException {  
        return compress(str, GZIP_ENCODE_UTF_8);  
    }
    
    public static byte[] uncompress(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        try {
            GZIPInputStream ungzip = new GZIPInputStream(in);
            byte[] buffer = new byte[256];
            int n;
            while ((n = ungzip.read(buffer)) >= 0) {
                out.write(buffer, 0, n);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return out.toByteArray();
    }
    
    public static String uncompressToString(byte[] bytes, String encoding) {  
        if (bytes == null || bytes.length == 0) {  
            return null;  
        }  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);  
        try {
            GZIPInputStream ungzip = new GZIPInputStream(in);  
            byte[] buffer = new byte[256];  
            int n;  
            while ((n = ungzip.read(buffer)) >= 0) {  
                out.write(buffer, 0, n);  
            }  
            return out.toString(encoding);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static String uncompressToString(byte[] bytes) {  
        return uncompressToString(bytes, GZIP_ENCODE_UTF_8);  
    } 
    
    public static void main(String[] args) throws IOException {
        String s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
        System.out.println("字符串长度："+s.length());
        System.out.println("压缩后：："+compress(s).length);
        System.out.println("解压后："+uncompress(compress(s)).length);
        System.out.println("解压字符串后：："+uncompressToString(compress(s)).length());
    }
}

#五、压缩效果

压缩前：



压缩后：




显然压缩后资源文件变得小了很多，加载速度也快了不少。可见，gzip压缩是页面性能优化的一种有效方式。

打包跟压缩的区别：

打包是指将多个文件或者目录放在一起，形成一个总的包，这样便于保存和传输，但是大小是没有变化的，压缩是指将一个或者多个大文件或者目录通过压缩算法使文件的体积变小以达到压缩的目的，可以节省存储空间，在压缩的时候通常是先打包再压缩；

tar命令

tar命令参数前面加”-"与不加“-”的区别：

tar命令参数前面加不加“-”执行命令的结果是没有区别的，区别只要是在于linux风格方面，加“-”属于System V风格，不加“-”属于BSD风格，所以在使用tar命令的时候它的参数加不加“-”结果是一样的，看个人的使用方式；

常用参数：

tar命令的常用参数
	
-z
			
是否同时具有gz属性
		
-j
			
是否同时具有bz2属性
		
-J
			
是否同时具有xz属性
		
-x
			
解压缩、提取打包的内容
		
-t
			
查看压缩包内容
		
-c
			
建立一个压缩，打包文档
		
-C
			
切换到指定目录，表示指定解压缩包的内容和打包的内容存放的目录
		
-v
			
显示压缩或者打包的内容
		
-f
			
使用文件名，在f后面要接压缩后的文件的名字，只要用到tar命令，-f选项是必须要用的，-f参数在使用的时候一定排在其他参数的后面，在最右边
		
-p
			
保留备份数据的原本权限与属性，常用于备份（-c）重要的配置文件
		
-P
			
保留绝对路径
		
一、打包

实例：

a.将/root/下的ceshi.txt文件和anaconda-ks.cfg文件和time.sh文件打包为一个文件，名称为“jihe.tar”：



b.查看jihe.tar文件的内容：



c.提取jihe.tar文件的内容到/opt目录下：



如果不用“-C”指定目录则会提取内容到当前目录

二、压缩

linux主要有三种压缩方式：

1.gzip：是公认的压缩这速度最快，压缩大文件的时候与其他的压缩方式相比更加明显，历史最久，应用最广泛的压缩方式

2.bzip：压缩形成的文件小，但是可用性不如gzip

3.xz：是最新的压缩方式，可以自动提供最佳的压缩率

建议的压缩的时候标明后缀：

参数
			
作用
			
命名方式
		
-z
			
用于gzip压缩方式
			
文件名.tar.gz
		
-j
			
用于bzip2压缩方式
			
文件名.tar.bz2
		
-J
			
用于xz压缩方式
			
文件名.tar.xz
		
实例：用不同的压缩方式压缩/root/目录下的Golden.apk文件

先查看Golden.apk文件的大小：



可以看到Golden.apk文件的大小为187M

a.用gzip压缩方式将Golden.apk文件压缩为Golden.apk.tar.gz文件：



b.用bzip2的压缩方式将Golden.apk文件压缩为Golden.apk.tar.bz2文件：



从上图可以看出红色方框内有报错，这个报错的原因是缺少bzip2的包，需要安装一个bzip2软件包



安装完成之后再重新压缩：



在压缩的过程中，我们可以发现：

压缩速度：gz > bz2 > xz

压缩率：xz > bz2 > gz



三、解压

先删除/root/目录下的Golden.apk文件：



tar命令式一个很聪明的命令，我们在解压的时候不需要指明自己压缩的方式它会自己选择跟压缩方式对应的方式去解压，这话说得有点拗口，例：

a.将Golden.apk.tar.gz解压到当前目录：



在解压gz压缩方式压缩文件的时候并不需要加上-z，直接用参数-xf即可，另外两种压缩方式在解压的时候一样，因为tar命令会自动选择，解压之后压缩文件还在，如果不指定解压出来的文件保存在哪里，那么会直接解压在当前目录

b.指定解压出来的文件保存的目录，将Golden.apk.tar.bz2文件解压在/opt/目录下：



补充：

a.在打包和压缩的过程中，我们有时候会看到这样的语句：tar: 从成员名中删除开头的“/”，这个并不是报错，是因为没有加上-P选项，没有保留原来的绝对路径去打包或者压缩，提取打包的内容跟解压一样，下面举一个例子：

将/root/目录以gzip的方式压缩为root.tar.gz压缩文件：

1.没有加-P选项：



2.加上-P选项：



解压的时候同理，如果在压缩文件的时候使用了-P选项，那么在解压的时候也要加上-P选项，不然也会出现”tar: 从成员名中删除开头的“/”“，如下图：

1.不加-P选项解压使用了-P选项压缩/root/后的root.tar.gz文件：



2.加上-P选项解压使用了-P选项压缩/root/后的root.tar.gz文件：




b.在使用tar压缩或者打包的时候，可以通过增加--exclude来达到排除指定的文件的目的

将/root/目录下的harry目录打包，但是不打包harry目录下的ha.txt文件，如下图：



压缩文件也是同理，想要排除指定的目录压缩或者打包也是同理

zip命令和unzip命令

#在使用zip跟unzip命令之前先查看系统有没有安装这两个命令的包，没有的话要自己安装

查看有没有安装zip跟unzip命令的命令：

rpm -q zip unzip



如果有安装了命令则会显示出命令的版本号

zip命令

基本用法：

zip [参数] [压缩包名] [压缩的目录或者文件的路径]

常用参数：

zip命令的常用参数
	
-m
			
将文件压缩后，删除原文件
		
-o
			
将压缩文件内的所有文件的最新变动时间设为压缩的时间
		
-q
			
安静模式，在压缩的时候不显示指令执行的过程
		
-r
			
递归压缩，将自定目录下的所有子文件以及文件一起处理
		
-x
			
”文件列表“，压缩时排除文件列表中的文件
		
 

实例：

a.压缩目录，将/root/目录下的harry目录压缩为名为harry.zip压缩包：

1.正常压缩，不加-q选项，显示压缩的过程：



2.加上-q选项，安静模式输出，不显示压缩的过程：



b.压缩多个文件，将/root/目录下的ceshi.txt文件和anaconda-ks.cfg文件和Golden.apk文件压缩为名为jihe.zip的压缩包：

因为压缩的全是文件，所以可以不用加上-r选项



c.压缩文件跟目录，将/root/下的ceshi.txt文件和anaconda-ks.cfg文件和harry目录压缩成名为dajihe.zip的压缩包：



d.将/root/目录下的harry目录压缩为harry1.zip压缩包，排除harry目录下的ha.txt文件：



unzip命令

基本用法：

unzip [参数] [压缩文件]  （-d [目录]）  //如果不是用括号里面的内容，则解压文件在当前工作目录

常用参数：

unzip命令的常用参数
	
-c
			
将解压缩的结果显示到屏幕上（显示每一个目录下的每一个文件的内容），同时对字符做适当的转换，但是并没有解压压缩包
		
-l
			
显示压缩文件内所包含的文件
		
-t
			
检查压缩文件是否正确
		
-v
			
执行时显示压缩文件的详细信息
		
-q
			
安静模式，执行时不显示任何信息
		
-d
			
指定文件解压后存储的目录
		
-x
			
指定不要处理压缩文件中的那些文件
		
实例：

a.将harry.zip压缩包解压缩的结果显示出来：



具体会显示到每一个文件跟每一个文件的内容

b.显示jihe.zip压缩包里面锁包含的文件



c.检查dajihe.zip压缩文件是否正确：



全部OK表示全部文件都是正确的

d.不解压压缩文件dajihe.zip，查看压缩包里面的内容（查看显示的文件列表还包含压缩比率）：



#使用-v显示的信息比使用-l显示的信息更加详细

e.将dajihe.zip压缩包解压到/opt/目录下：



补充：使用r选项增加.tar归档文件的内容应该如何怎么操作？

我们先来了解一下tar命令-r选项的作用：



通过tar --help命令查看帮助

-r选项的作用：把要存档的文件追加到档案文件的未尾。例如用户已经作好备份文件，又发现还有一个目录或是一些文件忘记备份了，这时可以使用该选项，将忘记的目录或文件追加到备份文件中

使用实例：



看上图，可以看到我ops用户家目录下标记了一个文件，一个目录，我现在先将目录归档，然后再将文件追加到档案里面

1.归档操作



生成.tar文件，目录归档完毕！

2.将calculating_time.sh追加进入.tar文件中



3.验证

a.查看.tar文件的归档信息





可以看到calculating_time.sh文件已经被追加到档案的末尾了

b.提取Check_Configuration_20201118_PM.tar 到/mnt目录下



使用-r选项追加文件至.tar文件成功

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

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

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

 

 

介绍哈夫曼：



 



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

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

例如，在英文中，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》文件属性：

对于我们这种资料特别多，随时都需要跟工作伙伴沟通传递资料的人来说，一款方便的压缩软件真的太重要了，不仅可以节省时间，节省内存，更重要的是提高工作效率，今天废鱼就给大家推荐几款常用压缩软件。

 

The Unarchiver 

The Unarchiver行为与系统自带的工具一致，文件类型图标精致有爱，操作简单易用， 可以帮助你存储不同类型的档案文件！ 可以打开一些常见格式的文件，比如Zip、Rar... 也可以打开一些较老格式的文件，比如ARJ、ARC... 你使用它打开文件时它会自动检测和修正文件编码， 使你在任何地方都不会得到乱码的文章。



下载：http://www.macbl.com/app/system/the-unarchiver

 

Archiver

Archiver是一个非常多才多艺的解压缩工具，它可以解压你所有的档案。如你有一个文件太大，无法放在磁盘上或通过电子邮件发送？借助Archiver，您可以将文件分割成任意大小的较小文件。可以压缩拆分文件来挤出一些额外的空间。当然，Archiver也可以通过加密档案保护您的文件，同时，你也可以将文件们拖到Archiver中来，提取多个档案同时解压。



下载：http://www.macbl.com/app/system/archiver

 

BetterZip

BetterZip是一款功能强大的压缩工具，它可以不解压就能预览文件，支持ZIP，TAR，TGZ，TBZ，TXZ等多种格式的文件。此外，它还能让文件在Windows 和Linux系统中兼容。



下载：http://www.macbl.com/app/utilities/betterzip

 

Dr. Unarchiver

在正版的Mac解压缩软件中，免费又好用的解压软件确实是非常少见的，它像解压缩界一股清流。Dr.Unarchiver支持所有常见格式：如RAR、7z、ZIP、XZ、BZIP2、GZIP、RAR、WIM、ARJ、CAB、CHM、CPIO、CramFS、DEB、DMG、FAT、HFS、ISO、LZH、LZMA、MBR、MSI、NSIS、NTFS、RPM、SquashFS、UDF、VHD、WIM、XAR 以及 Z等。

 



下载：http://www.macbl.com/app/utilities/dr.-unarchiver

 

Rar Sharp

Rar Sharp for mac是一款Mac上的压缩解压缩工具，支持常用的压缩格式，如rar, zip, gzip, tar等格式，支持压缩包内文件预览、解压缩部分内容、密码加密、拖拽压缩解压等功能。



下载：http://www.macbl.com/app/system/rar-sharp

 

keka

一开始是被keka的图标吸引过来，虫子恐惧症的患者还是不要尝试去下载了。但是撇开图标不谈，keka是一款优秀又小巧的压缩、解压缩软件，速度很快还支持Growl，压缩时也不会把OSX的fork类隐藏文件也给压进去。它所支持的文件压缩格式：7z, Zip, Tar, Gzip, Bzip2；支持的文件解压缩格式：RAR, 7z, Lzma, Zip, Tar, Gzip, Bzip2, ISO, EXE, CAB, PAX, ACE (PPC)等。



下载：http://www.macbl.com/app/system/keka

 

以上就是今天推荐的六款解压缩软件，如果你也知道哪些实用的压缩软件，欢迎在下面留言，本文将不定时更新，我们下次见咯~