在日常生活中，使用电脑必然少不了跟压缩文件打交道，所以压缩软件五花八门，解压速度各有不同，软件各有千秋吧，在这介绍的是我用了很久的一款压缩解压软件——7zip。
 
这款软件体积小，安装方便，没有广告！！！使用方便。
 
一、关于安装
 
这个安装由于软件免费，体积小，官网就可以即刻下载，我就不推百度云了，大家可以直接百度搜索7zip，或者直接点击这儿进入官网，根据你的电脑选择下载安装包，随意就好。。。。。。下载完成后双击进行安装，选择安装目录什么的，就不多讲了......
 
 
2、关于使用
 
安装完很多同学问我，从哪找这个软件呢，关于这个，可能是一个小小的缺点吧，不能预览这个压缩包里面有什么东西，那这个软件怎么用呢，其实它已经集成到，鼠标右键了，在资源浏览器找一个压缩包，右击它，就会有7zip的选项进行选择了.......没错！就是这样用法！！！
 
 
 
 
 
 
 
 
到此，这一期的好东西分享就结束了，后续我还会更新很多有意思的东西，软件之类，有什么不对的地方还希望各位指出批评，有什么可改进的地方我会在后期进行更新！！如有任何问题，请邮件2905257286@qq.com。

 
目录
 
一、概要设计
二：设计效果展示：
三、源代码
1°MainWindow.h
2°MainWindow.cpp
3°Compression.h
4°Compression.cpp
   
四、软件分析
 


 诸位既然点开了本帖，相信对此问题已有初步了解，哈夫曼树的原理不再赘述，我们开门见山，直入主题。
 
一、概要设计
 
问题拆解：设计一个基于哈夫曼编码的解压缩软件，这个问题我认为可以分解为以下几个子问题：
 
读取传入文件，进行字符权重统计
将出现的字符放入哈夫曼树结点，构建哈夫曼树，获取哈夫曼编码
将编码相关信息写入压缩后的文件，再将传入文件的每个字符按照哈夫曼编码转换，每8个二进制位作为一个字节传入压缩后的文件
解压部分：将传入的已压缩文件进行文件流读取，获取编码信息进行还原
 
根据这几个子问题的思路顺序，我们逐个击破，寻找解决方案：
 
读取传入文件，需要用到文件流。这里推荐使用Qt自带的QFile文件流配以QDatastram辅助。因为，C++的文件流fstream无法识别中文路径（一说起这个，就想起Debug时的辛酸）。权重统计我用的是map记录：map<unsigned char ,int>Weightmap。
哈夫曼结点的构造，和二叉树没有什么区别，只是在封装的struct里面加了unsigned char 型的字符，int型的权重，string型的哈夫曼编码，和是否是叶子结点的bool型标记（哈夫曼树叶子结点才是我们需要的编码）。将前面我们获取到的字符和权重加进去。
 我们将建立好的结点放入到一个vector内（理论上什么容器都可以），进入循环：根据哈夫曼结点的权重比较进行排序（直接调用sort），每次将连个最小的结点权重取出，相加得到权重和，以权重和建立一个新的结点，新结点的左右孩子结点就是这两个结点，将新结点加入到vector中，那两个结点删除。循环结束条件为vector内只剩下一个结点。这个结点便是哈夫曼树的根结点，保存一根结点足矣。
 我们从根结点出发遍历，左子树的string+“0”，右子树的string+“1”。并将unsigned char型的字符与这个string用map<unsigned char,string> PasswordMap 记录。
传入辅助信息阶段：我们传入的信息有，PasswordMap.size()，循环传入PasswordMap->first（字符）,PasswordMap->second.size()（记录编码长度）,PasswordMap->second（这个字符串有可能超过8位，每个字节不足8位的部分补0）直到完全传入。另外一个方法是将所有字符与字符权重传入，在解压缩时再次构建哈夫曼树，两种思路我觉得都可以。这里我采用的第一种方法。
 传入哈夫曼编码阶段：遍历先前在读取文件时获取的字符串，将字符串的每一位转化为哈夫曼编码，用另一个字符串储存。这里不妨称这个字符串为二进制字符串，这个二进制字符串按8分割到最后可能会有不足8位的部分，对其进行补0操作。 最后再传入一个字节，记录补0数。
解压部分：对应上部分的操作进行对应读取，主要思路是将压缩时传入的辅助信息提取，建立一个新的Map映射，根据这个映射，将原文件还原。
 
二：设计效果展示：
 
压缩前：
 
 压缩中：
 
 压缩后：
 
 解压中：
 
 解压后：
 
 
三、源代码
 
前面分析得很清晰，不过写代码的过程异常艰辛，充满了Debug时的汗水和泪水。
 完整代码与封装好的可执行文件下载链接：https://gitee.com/sherlocknovitch/Qt_Compression
 (可执行文件有58M，是因为封装了Qt的核心控件，去掉这些估计只有几百Kb的大小)
 上代码：
 
1°MainWindow.h
 
先从窗口头文件看起，这块没有什么实质性的内容，只有几个槽函数（3个按钮的Click槽函数加一个让QprogressBar动起来的槽函数和一个出现文件打开错误情况时让QLineEdit清空的槽函数）
 私有成员中QStirng path的作用是读取文件路径，作为压缩函数和解压缩函数的参数。
 Compression* com是一个类指针，这个类是压缩类，在后面会提及。
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include"compression.h"
#include<QFileDialog>
#include<QMenu>
#include<QAction>


namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    void clear();
private slots:
    void on_pushButton_open_clicked();

    void on_pushButton_compression_clicked();

    void on_pushButton_decompression_clicked();

    void myslot(double per);

private:
    Ui::MainWindow *ui;
    Compression* com;
    QString path;
};

#endif // MAINWINDOW_H
 
2°MainWindow.cpp
 
这一块主要含义见注释即可，QProgressBar是Qt的一个控件，可以理解为进度条
 
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    resize(600,600);
    //设置窗口大小
    setWindowTitle("Sherlock's Compression");
    /设置窗口名称
    com=new Compression();
    //初始化压缩类指针
    connect(com,&Compression::error,this,&MainWindow::clear);
    //异常情况的信号接收
    connect(com,SIGNAL(mysignal(double)),this,SLOT(myslot(double)));
    //让QProgressBar随着压缩/解压缩进度更新
    ui->progressBar->setMaximum(100);
    //QProgressBar的最大值设为100
    ui->progressBar->setMinimum(0);
    //QProgressBar的最小值设为0
    ui->progressBar->setValue(0);
    //QProgressBar显示的值初始化为0
    QMenu* pFile=ui->menuBar->addMenu("帮助");
    //添加菜单栏
    QAction* pNew=pFile->addAction("关于此压缩软件");
    //添加菜单栏下的一个动作
    connect(pNew,&QAction::triggered,[=]()
    {
        QMessageBox::about(this,"关于此压缩软件",""
                                         "此乃数据结构大作业,余制之于庚子年辛巳月丙子日。该压缩软件可能存在一些Bug(运行过程中可能会卡顿，不要点击，否则可能强退），时间原因无法全面排查，如您在使用过程有所发现，欢迎反馈。");
        //点击时弹出的窗口
    });
}

MainWindow::~MainWindow()
{
    delete ui;
    delete com;
}

void MainWindow::clear()
{
    ui->lineEdit->clear();
    path.clear();
}
//在文件打开失败的情况下清空所有

void MainWindow::myslot(double per)
{
    if(per>ui->progressBar->value())
        ui->progressBar->setValue(per);
}
//per是进度，信号是由ComPreesion类指针发出，这是槽函数

void MainWindow::on_pushButton_open_clicked()
{
    path=QFileDialog::getOpenFileName(this,QString("选择文件"));
    ui->lineEdit->setText(path);
}
//UI界面“选择”按钮的槽函数，更新path和lineEdit内容


void MainWindow::on_pushButton_compression_clicked()
{
    com->zip(path);
    ui->lineEdit->clear();
    this->path.clear();
    ui->progressBar->setValue(0);
}
//UI界面“压缩”按钮的槽函数，将path作为参数传给压缩类的压缩函数，压缩完毕后，清除lineEdit，path，progressBar

void MainWindow::on_pushButton_decompression_clicked()
{
    com->unzip(path);
    ui->lineEdit->clear();
    this->path.clear();
    ui->progressBar->setValue(0);
}
// UI界面“解压”按钮的槽函数，思想与前者相同
 
3°Compression.h
 
在这一块定义哈夫曼树节点，定义了压缩类，具体见注释
 
#ifndef COMPRESSION_H
#define COMPRESSION_H

#include <QMainWindow>
#include<QMessageBox>
#include<QFile>
#include<QDataStream>
#include<QString>
#include<map>
#include<string>
#include<vector>
#include<algorithm>
#include<ctime>

using namespace std;

struct HuffmanTreeNode
{
    pair<unsigned char, int>Weight;  //记录字符和其权重
    string zippassword;                //等待获取的哈夫曼编码
    HuffmanTreeNode* leftson;   //左儿子指针
    HuffmanTreeNode* rightson;  //右儿子指针
    bool tag;               //是否为叶子结点的标记，true为非叶子结点
};
//哈夫曼树结点

class Compression : public QMainWindow
{
    Q_OBJECT
public:
    explicit Compression(QWidget *parent = nullptr);
    void zip(QString path);        //压缩函数
    void unzip(QString path);   //解压函数
protected:
    void DEL(HuffmanTreeNode*& root);   
    //在每次压缩后需要delete掉申请空间的哈夫曼树指针，采用递归遍历进行delete
    
    void BinaryString_Init();
    //二进制字符串的初始化，即从传入文件得到的字符串按照哈夫曼编码获取二进制字符串
    
    void Weightmap_Init(QFile& in);
    //参数是QFile型，是Qt的文件操作，该函数打开传入文件，遍历，形成一个字符串，并且初始化WeightMap
    
    HuffmanTreeNode* MakehuffmanTreeNode(int i);
    //该函数的功能是创建单个哈夫曼树结点
    
    void HuffmanTreeVector_Init();
    //将创建的哈夫曼结点放入Vector中
    
    void HuffmanTree_Init();
    //建立哈夫曼树的函数
    
    void ZipPassword_Init(HuffmanTreeNode* &root, string& password);
    //对建成的哈夫曼树进行遍历，更新每个结点的zippassword,即哈夫曼编码
    
private:
    map<unsigned char, int> weightmap;  //权重映射
    map<unsigned char, string>passwordmap;  //哈夫曼编码映射
    string source_string;       //读取传入文件形成的字符串
    string binary_string;      //通过哈夫曼编码映射形成的二进制字符串
    vector<HuffmanTreeNode* > container;  //哈夫曼结点储存的容器
    map<string, int> zippassword;       //解压时建立的解码映射
signals:
    void error();                      //信号
    void mysignal(double per);  //信号
public slots:
};

#endif // COMPRESSION_H
 
4°Compression.cpp
 
进入重头戏。
 该函数将二进制串转为int型，即将压缩时每8个二进制位的字符串转化为ASCII码，传入压缩后的文件
 
int binarystringtoint(string binarystring)
{
    int sum = 0;
    for (int i = 0; i < binarystring.size(); i++)
    {
        if (binarystring[i] == '1')
        {
            int j = pow(2, binarystring.size() - i - 1);
            sum += j;
        }
    }
    return sum;
}
 
int转化为string，是上面那个函数的反操作，在解压时使用
 
string inttobinarystring(int value)
{
    string binarystring;
    while (value > 0)
    {
        int r = value % 2;
        if (r == 1)binarystring.insert(0, 1, '1');
        else binarystring.insert(0, 1, '0');
        value = value / 2;
    }
    if (binarystring.size() < 8)
    {
        binarystring.insert(0, 8 - binarystring.size(), '0');
    }
    return binarystring;
}
 
这个函数是哈夫曼结点间比较的依据，作为sort函数的参数
 
bool compare(HuffmanTreeNode* node1, HuffmanTreeNode* node2)
{
    return node1->Weight.second < node2->Weight.second;
}
 
这是删除整颗哈夫曼树的函数
 
void Compression::DEL(HuffmanTreeNode*& root)
{
    if(root==NULL) return;
    DEL(root->leftson);
    DEL(root->rightson);
    delete root;
}
 
此函数功能为sourcestring按照哈夫曼编码映射初始化类中的binarystring
 
void Compression:: BinaryString_Init()
{
    for (int i = 0; i < source_string.size(); i++)
    {
        binary_string+= passwordmap[source_string[i]];
    }
}
 
权重映射的初始化，涉及到QFile的操作，实际上和C++的fstream差不多,不过功能比其强大.
 
void Compression::Weightmap_Init(QFile& in)
{
        QByteArray a;
        while (!in.atEnd())
        {
            a=in.read(1024);   
            //一次性读取1024个字节，不足1024个字节则读取全部
            
            string b=a.toStdString();
            //转换为我们亲切的string
            
            for(int i=0;i<b.size();i++)
            {
                unsigned char ch=b[i];
                source_string += ch;
                weightmap[ch]++;
            }
        }
}
 
建立哈夫曼结点函数：进行初始化操作
 
HuffmanTreeNode* Compression::MakehuffmanTreeNode(int i)
{
    HuffmanTreeNode* huffman = new HuffmanTreeNode;
    huffman->Weight.first = i;
    huffman->Weight.second = weightmap[i];
    huffman->tag = 0;
    huffman->leftson = NULL;
    huffman->rightson = NULL;
    return huffman;
}
 
初始化结点容器：
 
void Compression::HuffmanTreeVector_Init()
 {
     for (map<unsigned char, int>::iterator it = weightmap.begin(); it != weightmap.end(); it++)
         {
             HuffmanTreeNode* huffman = MakehuffmanTreeNode(it->first);
             container.push_back(huffman);
         }
 }
 
建立哈夫曼树的函数，基本上就是原理的实现
 
void Compression::HuffmanTree_Init()
 {
     while (container.size() != 1)
         {
             sort(container.begin(), container.end(), compare);
             int sum = container[0]->Weight.second + container[1]->Weight.second;
             HuffmanTreeNode* newhuffman = new HuffmanTreeNode;
             newhuffman->Weight.second = sum;
             newhuffman->Weight.first = 0;
             newhuffman->tag = 1;
             //标记为非叶子结点
             newhuffman->leftson = container[0];
             newhuffman->rightson = container[1];
             container.erase(container.begin());
             //删除后迭代器会顺移到下一位
             container.erase(container.begin());
             container.push_back(newhuffman);
         }
 }
 
递归更新哈夫曼编码函数：这个函数的关键是每次递归返回时password进行一次pop操作。
 
 void Compression::ZipPassword_Init(HuffmanTreeNode* &root, string& password)
 {
     if (root != NULL && !root->tag)
         {
             root->zippassword = password;
             passwordmap[root->Weight.first] = password;
         }
         if (root->leftson != NULL)
         {
             ZipPassword_Init(root->leftson, password += "0");
             password.pop_back();
         }
         if (root->rightson != NULL)
         {
             ZipPassword_Init(root->rightson, password+="1");
             password.pop_back();
         }
 }
 
压缩函数：
 
void Compression::zip(QString path)
 {
     clock_t begin=clock();   //记录开始时间
     QFile openfile(path);   //创建QFile
     if(!openfile.open(QIODevice::ReadOnly))   //打开文件,若不成功，发射信号，结束。
     {
         QMessageBox::information(NULL,QString("警告"),QString("文件打开失败"));
         emit error();
         return;
     }
     Weightmap_Init(openfile);   //权重映射初始化
     emit mysignal(10);  //更新进度条
     HuffmanTreeVector_Init();    //哈夫曼结点容器初始化
     emit mysignal(20);
     HuffmanTree_Init();  //构建哈夫曼树
     emit mysignal(30); 
     string empty=""; 
     ZipPassword_Init(container[0],empty);   //哈夫曼编码映射初始化
     emit mysignal(40);
     BinaryString_Init();         //获取二进制串
     emit mysignal(50);
     path+=".HuffmanZip";    //压缩后的文件格式后缀
     openfile.close();        //关闭openfile
     QFile savefile(path);       //创建新的Qfile进行压缩文件的写入
     savefile.open(QIODevice::WriteOnly);  //打开
     QDataStream out(&savefile);        //利用QdataStream进行接下来的操作，这就类似于fstream了
     int size = passwordmap.size();
         if (size == 256) size = 0;  //因为256无法用一个字节保存
         int length = 0;       //这个length没用的，忘记删除了
         out<<size;           //传入哈夫曼编码映射数量
         length++;
         double k=1;
         for (map<unsigned char, string>::iterator it = passwordmap.begin(); it != passwordmap.end(); it++)
         {
             emit mysignal(50+double(25*k++)/passwordmap.size());
             int first = it->first;
             out<<first;       //传入key值
             length++;
             string second = it->second;
             int size = second.size();
             out<<size;    //传入value值的长度
             length++;
             int n = 8 - second.size() % 8;
             if (n)
             {
                 second.append(n, '0');  //补0
             }
             for (int i = 0; i < second.size(); i += 8)
             {
                 string k = second.substr(i, 8);
                 int temp = binarystringtoint(k);
                 unsigned char ch = temp;
                 out<<ch;           //传入value值
                 length++;
             }
         }
         int n = 8 - binary_string.size() % 8;
         if (n)
         {
             binary_string.append(n, '0');
         }
         length++;
         int totalbitsize = binary_string.size() / 8;
         for (int i = 0; i < binary_string.size(); i += 8)
         {
             emit mysignal(75+double(25*i)/binary_string.size());
             string k = binary_string.substr(i, 8);
             int temp = binarystringtoint(k);
             unsigned char ch = temp;
             out<<ch;              //分8个字节依次传入
             length++;
         }
         unsigned char temp=n;
         out<<temp;       //传入补0数量
         length++;
         emit mysignal(100);
         int newlength=savefile.size();
         savefile.close();
         clock_t end=clock();        //结束时间
         QString tip("理论压缩比:");
         tip+=QString::number(double(totalbitsize * 100) / source_string.size());
         tip+="%,实际压缩比：";
         tip+=QString::number(double(newlength * 100) / source_string.size());
         tip+="%,压缩用时：";
         tip+=QString::number(double(end-begin)/CLOCKS_PER_SEC);
         tip+="s";
         QMessageBox::about(this,"压缩说明",tip);
         //弹窗提示本次压缩情况
         
         weightmap.clear();
         passwordmap.clear();
         source_string.clear();
         binary_string.clear();
         DEL(container[0]);
         container.clear();
         //结束后的处理
 }
 
解压函数：思路同压缩函数类似
 
void Compression::unzip(QString path)
 {
     clock_t begin=clock();
     if(path.right(11)!=".HuffmanZip")
     {
         QMessageBox::information(NULL,QString("警告"),QString("此文件非哈夫曼压缩文件，打开失败"));
         emit error();
         return;
     }
     QFile openfile(path);
     if(!openfile.open(QIODevice::ReadOnly))
     {
         QMessageBox::information(NULL,QString("警告"),QString("文件打开失败"));
         emit error();
         return;
     }
     QDataStream in(&openfile);
     int zipmapsize;
     in>>zipmapsize;
         if (zipmapsize == 0) zipmapsize = 256;
         for (int i = 1; i <= zipmapsize; i++)
         {
             int zipkey;
             in>>zipkey;
             int valuelength;
             in>>valuelength;
             string valuestring;
             for (int i = 1; i <= valuelength / 8 + 1; i++)
             {
                emit mysignal(double(20*i)/(valuelength/8 +1));
                unsigned char ch;
                in>>ch;
                int zipvalue=ch;
                 valuestring += inttobinarystring(zipvalue);
             }
             valuestring.erase(valuelength, valuestring.size() - valuelength + 1);
             zippassword[valuestring] = zipkey;
         }
         string zipstring;
         while (!in.atEnd())
         {
             unsigned char ch;
             in>>ch;
             int bit=ch;
             zipstring += inttobinarystring(bit);
         }
         emit mysignal(50);
         int zerosize = binarystringtoint(zipstring.substr(zipstring.size() - 8));
         zipstring.erase(zipstring.size() - zerosize - 8, zerosize + 8);
         openfile.close();
         path.chop(11);
         path.insert(path.lastIndexOf('.'),"(New)");
         QFile savefile(path);
         savefile.open(QIODevice::WriteOnly);
         string str;
         for (int i = 0; i < zipstring.size(); i++)
         {
             emit mysignal(50+double(50*i)/zipstring.size());
             str += zipstring[i];
             map<string, int>::iterator it = zippassword.find(str);
             if (it != zippassword.end())
             {
                 unsigned char temp=it->second;
                 savefile.write(reinterpret_cast<char*>(&temp),1);
                 str.clear();
             }
         }
         emit mysignal(100);
         savefile.close();
         clock_t end=clock();
         QString tip="解压用时:";
         tip+=QString::number(double(end-begin)/CLOCKS_PER_SEC);
         tip+="s";
         QMessageBox::about(this,"解压说明",tip);
         zippassword.clear();
 }
 
感谢您把本弱鸡的代码看完了，如果方便的话，可以点个赞吗
 
四、软件分析
 
测试了各种类型的文件，每种文件压缩效率是不同的。
 
文件类型
pdf
doc
docx
txt
cpp
py
exe
xlsx
png
bmp
jpg
gif
ppt
文件大小
6.26M
124KB
432KB
679KB
6.43KB
5.01KB
73.5KB
12.3KB
41.9KB
308KB
29KB
34.3KB
2.45M
压缩后大小
6.26M
98.8KB
435KB
493KB
5.25KB
4.43KB
59KB
14.4KB
44KB
170KB
31.4KB
36.7KB
2.23M
理论压缩比
99.9085%
77.4442%
100%
72.5954%
66.2418%
62.028%
76.9279%
97.5236%
99.1657%
54.4023%
99.6274%
99.7214%
90.794%
实际压缩比
99.9474%
79.431%
100.579%
72.6815%
81.6568%
88.4196%
80.296%
117.747%
105.122%
55.2083%
108.188%
106.985%
90.893%
压缩时间
4.683s
0.093s
0.375s
0.457s
0.014s
0.015s
0.068s
0.025s
0.042s
0.178s
0.036s
0.039s
2.114s
解压时间
19.647s
0.273s
1.295s
1.297s
0.015s
0.009s
0.2s
0.044s
0.141s
0.471s
0.096s
0.105s
7.224s
从这个表格可以得出，哈夫曼编码的压缩比取决于文件类型以及文件大小。doc，bmp，txt，cpp，py，exe文件压缩效果相对较好，其中bmp最优。
 我认为一些文件压缩效率较差的原因为：
 
文件规模较小，传入的辅助信息量相对较大
文件中每个字符都出现且频率分布集中，导致了哈夫曼编码长度基本上全部趋近于8，即哈夫曼树叶子结点几乎全在最底层，使压缩效率大打折扣。

第一：QVE视频压缩软件
 
下载地址：http://www.qvevideo.com/compress
 
非常实用的视频，图片两用压缩软件,能够将各种视频压缩成mp4,flv等格式, 缩减视频体积,释放磁盘空间,节省网络带宽,压缩后能够保持视频高清晰度,压缩率高达90%以上。
 
1，首先打开软件，切换到【图片压缩】界面，然后点击【添加图片】按钮，在弹出的文件对话框需要压缩的图片文件。
 
 
设置压缩模式和输出格式：
 
 提供三种压缩模式可选，普通压缩，压缩率相对较低，压缩后图片清晰度非常高；深度压缩，压缩率较高，相对普通压缩，图像质量略低；极限压缩，最大限度压缩文件体积，图像质量低于普通压缩，和深度压缩，设置压缩图片的输出格式。
 
一键压缩图片，全选需要压缩的图片，点击一键压缩，等待压缩进度显示完成，然后点击打开目录。
 
 
以上就是使用QVE视频压缩软件，压缩图片文件和压缩视频文件大小方法，如果你也有视频和图片需要减少体积，可以试试上述的方法。
 
第二：Tinypng
 
地址：https://tinypng.com/，在线压缩图片，需要上传到网站，如果有隐私不建议用在线，可以使用QVE视频压缩，本地安装，本地压缩。
 
 
第三：Compressor.io
 
地址：https://compressor.io/compress
 
使用Compressor很简单，只要上传图片就可以自动的压缩
 
 
如图所示，压缩之后的图片还可以保存在Google Drive 或者是Dropbox 上，这非常的方便。
 
另外Compressor支持压缩下面几种格式的照片：JPEG，PNG，GIF，SVG
 
第四：Kraken.io
 
工具地址：https://kraken.io/web-interface
 
 这个工具也是我常用的，我很喜欢他的一个功能是，你可以把Zip中的文件一次性导入到工具中进行压缩，同时它支持不同的格式同时进行压缩，如下图所示：
 
第五：Giftofspeed
 
JPG压缩：https://www.giftofspeed.com/jpg-compressor/
 
Png压缩：https://www.giftofspeed.com/png-compressor/
 
Giftofspeed相对上面几款工具来说，单独的把JPG，Png分开来测试，这个我觉得很麻烦。
 
但是Giftofspeed有一些功能是我很喜欢的，比如下图，你可以输入你的网址，然后这个工具会建议你对图片进行优化，这样你就可以发现很多问题。
 
 测试地址：https://www.giftofspeed.com/image-delivery/
 
 
另外Giftofspeed 其实还提供了很多有用的工具，几乎能一站的检测你的网站，
 地址：https://www.giftofspeed.com/tools/
 
第六： OptimiZilla
 
地址：http://optimizilla.com/
 
 这个工具可以批量上传和批量压缩图片，一次可以上传20张图片；这个工具还有一个比较有意思的功能是，他的压缩程度大小可以有你自己来调节，而且是尽量的不改变画质，如上图所示，你可以看到 Quaility的条件按钮。
 
第七：Imagerecycle
 
工具地址：https://www.imagerecycle.com/
 
 这个工具可以对图片和PDF进行压缩，同时他也提供了对网站进行分析，只要你输入URL就可以得出报告。
 
以上分享的比较常用的图片压缩工具，有在线网站，也有软件，根据自己的需求去选择合适的压缩工具，小编使用的是QVE视频压缩软件，可以无损压缩图片大小，压缩导出速度也快，最终的是支持一键批量压缩，非常方便。

推荐Mac软件及教程类文章
 
​关注他
 
64 人赞同了该文章
 
使用Mac电脑，无论是解压软件还是压缩软件，都需要一款功能强大的Mac解压缩软件,一款好用的Mac解压缩软件能够让你的工作更有效率,打包和解压数据更稳定更安全。那么，MAC上好用的解压缩软件有哪些呢？哪款苹果Mac电脑解压缩软件好用呢？带着疑问小编分享几款macOS好用的压缩解压软件。
 
一、keka
 Keka for Mac是一款应用在Mac端的轻量级压缩解压工具，支持压缩：7z, Zip, Tar, Gzip, Bzip2。支持解压：RAR, 7z, Lzma, Zip, Tar, Gzip, Bzip2, ISO, EXE, CAB, PAX, ACE (PPC)。体积小，简单易用，而且速度较快.
 
Keka for Mac(mac压缩解压利器)
  
 
 
 
 
 
 
 
二、BetterZip
 
BetterZip 4 for Mac是一款运行在苹果电脑上面的解压神器，支持市面上所有的压缩格式、支持压缩包加密，而且不用解压即可预览文件，同时还具有窗口式的查看界面，解压部分文件等功能，这款mac解压工具支持的格式包括zip、gz、bz、bz2、tar、tgz、tbz、rar、7-zip、cpio、 arj、lha、lhz、cab、iso、chm、rpm、deb、nsis、sit、dd、hqx和bin等多种格式的文件。此外，它还能让你的Mac文件在Windows 和Linux系统中兼容，是名副其实的Mac装机必备软件！
 
BetterZip 4 for Mac(苹果专用解压缩软件)
  
 
 
 
 
 
三、eZip
 
eZip mac版是专为macOS设计的归档程序，具有简洁但功能齐全的功能。支持20多种流行的归档格式，如rar，zip，7z，tar，gz，bz2，iso，xz，lzma，apk，lz4。完全免费。
 
eZip for Mac(苹果压缩解压软件)
 
 
 
 
 
以上就是Macdown小编为您分享的MAC上好用的解压缩软件，每一款都是小编亲测，相信看了小编的文章 Mac电脑上哪个解压缩软件最好用？的疑问应该可以解开了，优点是各有千秋，亲们可以根据自己的使用习惯来选择。