前言
 
新搭建的集群，需要进行各种测试，于是让一个同事导入一些测试数据，大约1.4T左右。我进行了一个简单的hive测试
 
//故意增加shuffle
SELECT DISTINCT(COUNT id) FROM test_table;
 
谁知道…就这么一个简单的SQL，半个小时过去后，仍然没有出结果
 
追查原因
 
原来同事从ftp拉取过来的数据是gzip格式的，他直接导入到Hive表中…，而gzip格式的数据是不可切分的
 
如何理解不可切分
 
为了进一步理解gzip等不可切分的压缩格式，我做了个测试
 
 
上传测试数据
 
 说明：
 使用linux自带的gzip将testdata（拷贝了bigtable的数据，因为直接gzip bigtable，会删除原始数据）
 或者使用：
 
 说明：
 这样不但可以将原有的文件保留，而且可以将压缩包放到任何目录中，解压缩也一样可以看到bigtable.gz和testdata.gz大小一致
 
 
在hdfs根目录创建一个data目录、
 
 
[root@node02 data]# hadoop fs -mkdir /data
[root@node02 data]# hadoop fs -ls /
Found 2 items
drwxr-xr-x   - root supergroup          0 2020-01-04 05:47 /data
drwxrwxrwx   - root supergroup          0 2019-06-26 06:23 /tmp
 
上传压缩后的数据
 由于数据太小(大约50M)，仅有一个block，为了测试，自定义block块为10M：
 
hadoop fs -D dfs.blocksize=10485760 -put bigtable.gz /data
 

 
 
 
 
 
从上图中明显可以看到：gzip格式的数据，不支持切分的真正含义，并不是说HDFS不会将文件分布式的存储在各个节点，而是在计算的时候，不支持切分，也就是仅仅有一个split，从而也就是仅有一个map，这样的效率是及其低下的。
 （后面还会更详细的讲解）
 正常支持切分的数据，执行流程如下：
 
 

 而不持支切分的数据，如gzip格式的数据，就只有一个map:
 
 这样直接导致的结果就是：
 一个map任务处理N个HDFS块，而其中大多数块并没有存储在执行该map任务的节点上，执行的效率会非常低
 
既然这样，难道压缩数据就没有意义了吗？当然不是，而且在生产环境中数据都是经过压缩处理的，接下来详细讲解HDFS数据的压缩
 
详解HDFS文件压缩
 
 
文件压缩的两大好处
 （1）减少存储文件所需要的磁盘空间
 （2）加速数据在网络和磁盘上的传输
 
 
与Hadoop结合使用的常见压缩方法
 
 
压缩格式
工具
算法
文件扩展名
是否可切分
DEFLATE
无
DEFLATE
.deflate
否
gzip
gzip
DEFLATE
.gz
否
bzip2
bzip2
bzip2
.bz2
是
LZO
lzop
LZO
.lzo
否
LZ4
无
LZ4
.lz4
否
Snappy
无
Snappy
.snappy
否
 
 
说明：
 
 
DEFLATE是一个标准压缩算法，该算法的标准实现是zlib。没有可用于生成DEFLATE文件的常用命令行工具，因为通常都用gzip格式。注意，gzip文件格式只是在DEFLATE格式上增加了文件头和一个文件尾。.deflate扩展名是Hadoop约定的。
如果LZO文件已经在预处理过程中被索引了，那么LZO文件是可切分的。
 
 
详细描述文件的压缩
 所有压缩算法都需要权衡空间/时间：压缩和解压缩速度更快，其代价通常是只能节省少量的空间。上表列出所有压缩工具都提供9个不同选项来控制压缩时必须考虑的权衡：选项-1为优化压缩速度，-9为优化压缩空间。例如，下述命令通过最快压缩方法创建一个名为file.gz的压缩文件：
 gzip -1 file
 不同压缩工具有不同的压缩特性。gzip是一个通用的压缩工具，在空间/时间性能的权衡中，属于其他两个压缩方法之间。bzip2的压缩能力强于gzip（即省空间），但压缩速度更慢一点。尽管gzip的解压速度比要锁速度快，但仍比其他压缩格式要慢一些。另一方面，LZO、LZ4和Snappy均优化压缩速度，其速度比gzip快一个数据量级，但压缩效率稍逊一筹。Snappy和LZ4的解压缩速度比LZO高出很多，通过下面的一张图更形象的看出：压缩比和压缩速度是相反的
 
 上表中的“是否可切分”列表示对应的压缩算法是否支持切分（splitable），也就是说，是否可以搜素数据流的任意位置并进一步往下读取数据。可切分压缩格式尤其适合MapReduce（这个原因上面有讲解，下面进行更详细的描述）
 
更详细的描述压缩和输入分片
 
在考虑如何压缩将有MapReduce处理的数据时，理解这些压缩格式是否支持切分（splitable）是非常重要的。以一个存储在HDFS文件系统中且压缩前大小为1GB的文件为例。如果HDFS的块大小设置为128MB，那么该文件将被存储在8个块中，把这个文件作为输入数据的MapReduce作业，将创建8个输入分片，其中每个分片作为一个单独的map任务的输入被独立处理。
 
现在想象一下，文件是经过gzip压缩的，且压缩后文件大小为1GB。与以前一样，HDFS将这个文件保存为8个数据块。但是，将每个数据块单独作为一个输入分片是无法实现工作的，因为无法实现从gzip压缩数据流的任意位置读取数据，所以让map任务独立与其他任务进行数据读取是行不通的。gzip格式使用DEFLATE算法来存储压缩后的数据，而DEFLATE算法将数据存储在一系列连续的压缩块中。问题在于每个块的起始位置并没有以任何形式标记，所以读取时无法从数据流的任意当前位置前进到下一块的起始位置读取下一个数据块，从而实现与整个数据流的同步。由于上述原因，gzip并不支持文件切分。
 
在这种情况下，MapReduce会采用正确的做法，它不会尝试切分gzip压缩文件，因为它知道输入的时gzip压缩文件（通过文件扩展名看出）且gzip不持支切分。这是可行的，但牺牲了数据的本地性：一个map任务处理8个HDFS块，而其中大多数块并没有存储在执行该map任务的节点上。而且，map任务数量越少，作业的粒度就越大，因而运行的时间可能会更长。
 
在前面假设的例子中，如果文件时通过LZO压缩的，我们会面临相同的问题，因为这个压缩格式也不支持数据读取和数据流同步。但是，在预处理LZO文件的时候使用包含在Hadoop LZO库文件中的索引工具时可能的，你可以在Google和Github网站上获得该库。该工具构建了切分点索引，如果使用恰当的MapReduce输入格式可有效实现文件的可切分特性。
 
另一方面，bzip2文件提供不同数据块之间的同步标识（pi的48位近似值），因而它支持切分。可以参考前面的表，了解每个压缩格式是否支持可切分
 
该使用哪种压缩格式
 
Hadoop应用处理的数据集非常大，因此需要借助与压缩。使用哪种压缩格式，与待处理的文件的大小、格式和所使用的工具有关。下面有一些建议，大致是按照效率从高到底排列的。
 
使用容器文件格式，例如顺序文件（Sequence File）、Avro数据文件、ORCFile或者Parquet文件，所有这些文件格式同时支持压缩和切分。通常最好与一个快速压缩工具联合使用，例如，LZO、LZ4或者Snappy
使用支持切分的压缩格式，例如bzip2（尽管bzip2非常慢），或者使用通过索引实现切分的压缩格式，例如LZO
在应用中将文件切分成块，并使用任意一种压缩格式为每个数据块建立压缩文件（不论它是否支持切分）。这种情况下，需要合理选择数据块大小，以确保压缩后的数据块的大小近似于HDFS块的大小
存储未经压缩的文件
 
 
 
对于大文件来说，不要使用不支持切分整个文件的压缩格式，因为会失去数据的本地性，进而造成MapReduce应用效率低下
 
 
后记
 
本文内容参考Hadoop权威指南

背景：看到文件压缩gzip,bzip2。脑子一热，想到能不能再次压缩文件？没有百度到，想要的答案，自己费事来try try。
 
看不懂的知识：https://blog.csdn.net/xuchuangqi/article/details/52939705
 
 
 
gzip 对于要压缩的文件，首先使用LZ77算法的一个变种进行压缩，对得到的结果再使用Huffman编码的方法（实际上gzip根据情况，选择使用静态Huffman编码或者动态Huffman编码，详细内容在实现中说明）进行压缩。所以明白了LZ77算法和Huffman编码的压缩原理，也就明白了gzip的压缩原理。我们来对LZ77算法和Huffman编码做一个简单介绍。
  
 
 
LZ77算法的压缩原理：使用滑动窗口寻找匹配串
 
 
LZ77从文件的开始处开始，一个字节一个字节的向后进行处理。一个固定大小的窗口（在当前处理字节之前，并且紧挨着当前处理字节），随着处理的字节不断的向后滑动，就象在阳光下，飞机的影子滑过大地一样。对于文件中的每个字节，用当前处理字节开始的串，和窗口中的每个串进行匹配，寻找最长的匹配串。窗口中的每个串指，窗口中每个字节开始的串。如果当前处理字节开始的串在窗口中有匹配串，就用(之间的距离，匹配长度) 这样一对信息，来替换当前串，然后从刚才处理完的串之后的下一个字节，继续处理。如果当前处理字节开始的串在窗口中没有匹配串，就不做改动的输出当前处理字节。
 
 
 
 
 
Huffman编码使用Huffman树来产生编码：统计每个符号（我们把字节的256种值看作是256种符号）的出现次数。然后根据符号的出现次数，建立Huffman树，通过Huffman树得到每个符号的新的编码。对于文件中出现次数较多的符号，它的Huffman编码的位数比较少。对于文件中出现次数较少的符号，它的Huffman编码的位数比较多。然后把文件中的每个字节替换成他们新的编码。
 
 
 
 
 正文：
 
压缩再压缩
 
一、单个文件的压缩再压缩
 
1、能否两次使用相同的命令进行压缩？
 
2、能否两次使用不同的命令进行交替压缩？
 
3、在上面的基础上 ，能否进行n次压缩？
 
二、目录文件的压缩
 
4、关心的是，目录中含有压缩文件，先打包目录文件，再压缩，目录内部的压缩文件的情况。
 
 
 
try 问题1：能否两次使用相同的命令进行压缩？
 
思路：在/tmp下建立一个目录testing1，目录中vim一个文件try1，用gzip命令连续最大程度压缩try1两次
 
 
上面说明，可以两次压缩。第一次压缩97.4%，文件大小由545byte变成45byte，文件变小。
 
                   第二次压缩11.1%，大小从45byte变成74byte，文件总体变大。
 
它们在图形界面下是这个样子。那压缩两次的文件是不是解压两次，才能变为原文件了？
 
 
 
 
种什么因故，得什么果。上面显示，压缩两次的文件，需要解压两次才行。
 
 
 
同样的方法，我们再试试能否用bzip2命令进行两次压缩。
 
 
这就挺有意思的， bzip2能压缩一次，压缩比为88.99%。但是再次压缩的时候，显示.bz2已经压缩过了。
 
那这是不是说，这就证明bzip2不能进行两次压缩呢？
 
好像并不能，咋们要是第一次压缩的时候，压缩出来的文件命名不含有.bzip，它能否接着压缩了？try try。
 
不急，咋们先进入图形界面中看一看，会发现一些好玩的现象
 
 
这里并不是再次压缩，try.bz2.bz2只是一个空壳子，里面没有东西。咋们验证一下。
 
 
好，咋们把上次的bzip2压缩的文件删除，通过bzip2命令把try压缩成trybz2。再将 trybz2一次压缩文件，用bzip2命令再次压缩。
 
 
上面说明，bzip2也能压缩文件两次。但是有.bz2后缀名的文件，无法用bzip2再次压缩。
 
 
 
try问题2：能否两次使用不同的命令进行交替压缩？
 
 
 结果当然也是可以的，即能使用不同的命令进行交替压缩。
 
那能否用bzi2压缩try.gz.bz2.gz呢？即try.gz.bz2.gz算不算含有.bz2?      答案是：try.gz.bz2.gz不算含有.bz2
 
 
我觉得上面已经够智障的，压缩n的事情就智障透顶了。丫的，花的时间有点多。
 
 
 
try问题4：关心的是，目录中含有压缩文件，先打包，再压缩，目录内部的压缩文件情况。
 
咋们先来猜一猜答案：我猜测，不会压缩打包文件中已经压缩的文件了。
 
实验是检验真理的标准。
 
首先是删除不必要的文件
 
 
再打包，压缩
 
 
但是，我也不知道，这包里的压缩文件有没有再次压缩。因为里面压缩和外面的压缩方式不同。
 
这是一个很有意思也很有价值的问题：目录中含有压缩文件，先打包，再压缩，内部的压缩文件会不会再次被压缩
 
这个问题留着，现在我解决不了。因为像bzip2那样，能认出自己已经压缩过的文件不奇怪。
 
但bzip2能不能识别出其他方式压缩出来的文件，并避免再次压缩呢?
 
这个问题留着，说不定，以后就知道了。（所有的压缩文件在前方有个统一的标注？）
 
 

写一个对文件进行压缩和解压缩的程序，功能如下：
 
① 可以对纯英文文档实现压缩和解压；
 
② 较好的界面程序运行的说明。
 
 
 
 
 
介绍哈夫曼：
 
 
 
 
 
效率最高的判别树即为哈夫曼树
 
在计算机数据处理中，霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。
 
例如，在英文中，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》文件属性：
 

压缩文件密码破解
 
如果你想要破解是很难的，不知道你的密码长度有多少，破解所需的时间是根据你的密码长度来算的，方法我给你：
 
1.WINZIP压缩文件的破解

 针对WINZIP压缩文件，黑客最常使用的工具就是Elcomsoft公司的“Advanced ZIP Password Recovery”（简称AZPR），AZPR提供了一个图形化的用户界面，黑客经过几个简单的步骤就可以破解ZIP压缩文件包的密码。

 第一步：配置破解工具

 首 先在“ZIP password-encrypted file”打开被加密的ZIP压缩文件包，可以利用浏览按钮或者功能键F3来选择将要解密的压缩文件包；在“Type of attack”中选择攻击方式：包括“Brute-force”（强力攻击）、“mask”（掩码搜索）、“Dictionary”（字典攻击）等；在 “Brute-force range options”设定强力攻击法的搜索范围，如果用户了解口令的组合特点，通过设定以下选择可以大大缩短搜索时间；在“Start from”中 ，当用户知道口令的起始字符序列时，可以设定该选项。例如，当用户知道口令全部使用小写字母，长度是5，并且以字母“k”开头，那么可以在该项填写 “kaaaa”，AZPR将从这个口令开始依次向后搜索所有的可能密码；在“Password length”中可以设定口令长度，这也是一个决定搜索时间的重要选项； “Auto-save”：自动存储选项的功能是定期自动保存软件当前设置与当前工作状态，这些关键参数将会定期自动保存在一个名为 “~azpr.ini”，用户可以自行指定保存参数的文件名、自动保存的时间间隔等等，该选项使得用户能够继续上次中断的解密进程。
 第二步：开始破解

 经 过以上几个关键的选项的设置，黑客就可以开始破解你的ZIP文件了，点击“Start”按钮即可进行解密运算，由于AZPR有以上保存参数和状态的功能， 用户随时可以中断或者继续运算过程。当密码找到后，用户会在结果窗口中看到密码内容、试探密码总数、破解消耗时间、平均运算速度等信息。如果没有找到密 码，也会有相应的提示信息。

 2.WINRAR压缩文件的破解

 针对WINRAR压缩文件，Elcomsoft公司也推 出了“Advanced RAR Password Recovery”，该软件解密速度很快，可以帮你找回RAR文件的密码，注册后可以解开多达128位密码。它提供有预估算出密码所需要的时间；可中断计 算与恢复继续前次的计算。然而到黑客手里也就变成了一个破解的工具，其具体使用方法与“Advanced ZIP Password Recovery”大致相同，这里不多介绍了。
 3. 当心“多功能密码破解软件”作祟

 此外，目前还有一款名为“多功能密码破 解软件”的工具值得大家注意，也是黑客经常使用的。该软件可以破解Access97/2000/xp密码，Word/Excel97/2000/xp、 QQ（本地和在线）、SQLSERVER（本地和远程）、windows98登陆密码、ZIP/RAR文件密码，星号密码察看，可以察看任何显示为*的密 码内容（网页除外）。ZIP/RAR文件密码也难逃该软件一“劫”！下面看看黑客到底是如何利用这个工具兴风作浪的。

 黑客安装并运行该软件，切换到“ZIP/RAR”选项
 点击“浏览”按钮找到本地硬盘上要破解的ZIP/RAR文件，然后需要进行以下的设置：

 （1）“破解位数设置”：你可以设置好密码最小长度和密码最大长度。

 （2）“破解字符设置”：你可以选择是用数字、小写字母、大写字母中一个或者多个，这需要根据设置的压缩包的密码来进行选择，当然，如果都选的话，那么破解的速度肯定更慢，花费的时间也更长。

 设置完毕后，点击“开始”按钮即可进行破解，经过一段时间的破解后，最后在“进度”框中显示破解的密码，
 三、巧妙设置，让压缩文件无懈可击

 除 了用来压缩文件，我们还常常把WinRAR、WINZIP当作一个加密软件来使用，在压缩文件的时候设置一个密码就可以达到保护数据的目的了。正因为如 此，专门针对压缩文件密码的破解软件也是遍地开花。密码的长短对于现在的破解软件来说，已经不是最大的障碍了。那么，怎样才可以让压缩加密的文件牢不可破 呢？ 除了做好日常的安全防范工作外，我们还要巧妙进行以下设置：

 现在的破解软件在破解加密文件密码的时候总要指定一个Encrypted File(目标文件)，然后根据字典使用穷举法来破解密码。但是如果我们将多个需要加密的文件压缩在一起，然后为每一个文件设置不同的密码，那破解软件就无可奈何了，具体操作如下：

 1.按照常规的方法把它压缩并且设置一个密码；
 2.准备一个其他文件(当然这个文件小一点最好了，因为我们只是利用它来迷惑破解软件而已)；
 3.在WinRAR的工作窗口中打开我们第一步已经压缩好的加密文件，在“命令”菜单中选择“添加文件到压缩包”菜单选项
 4.在弹出的“请选择要添加的文件”对话框中选择我们准备的“其他文件”，点击“确定”按钮后回到“压缩文件名字和参数”对话框；

 5.在“高级”选项卡标签中点击“设置密码”按钮设置一个不同的密码，然后开始压缩即可
 经 过以上步骤，现在两个密码已经设置完成了(如果添加了多个文件，也可以给每个文件设置不同的密码，如果你担心自己会忘记，只设两个密码也可以达到目的)。 打开压缩文件可以看到每一个文件名的右上角都有一个表示加密的星号，但是打开其中不同的文件都需要相对应的密码，使用破解软件是得不到正确密码的。这种方 法对用WinZip加密的文件同样适用。
 
 
我上网下载了rar压缩文件，有密码，用arpr工具怎么破解不了，
 
ARPR这个东西很难弄到正版的，所以一般只能三位密码以内的破解，即使弄到正版的你不知道加密时用的密码库，密码位数，给你连续破一年也不一定解出来，所以最好联系加密的人。毕竟也是加了密的，自己破解也不合法
 
 
 
 
用ARPR破解压缩包为什么破解的密码只有A
 
你是下的那个所谓的汉化版吧...哪个版本有问题的...首先我反对这些软件...不过你想要的话留下邮箱我发给你
 
 
如何破解RAR文件的压缩密码？
 
上网找破解工具啊，下面是我Www.BKJIA.com以前收集过的不知道还能不能下，呵呵，你看看，如果不能你可以自己上网搜搜的

 多功能密码破解软件：
 http://www.onlinedown.net/soft/38220.htm

 Advanced RAR Password Recovery
 http://www.onlinedown.net/soft/8271.htm

 RAR Password Cracker
 http://www.onlinedown.net/soft/4895.htm

 Turbo ZIP Cracker V0.3
 ZIP密码暴破工具，支持由WinZIP、PKZIP以及其它兼容ZIP格式的软件（比如WinRAR等）加密的ZIP压缩包，破解速度比较理想。
 http://www.skycn.com/soft/22909.html