精华内容
下载资源
问答
  • 但是如果我们想使用Flink内置sink API将数据以压缩的格式写入到HDFS上,好像并没有找到有API直接支持(如果不是这样的,欢迎留言纠正)。本文将介绍如何将数据gz压缩格式将处理后的数据写入到HDFS上。主要实现代码...

    Flink中我们可以很容易的使用内置的API来读取HDFS上的压缩文件,内置支持的压缩格式包括.deflate,.gz, .gzip,.bz2以及.xz等。

    但是如果我们想使用Flink内置sink API将数据以压缩的格式写入到HDFS上,好像并没有找到有API直接支持(如果不是这样的,欢迎留言纠正)。本文将介绍如何将数据以gz压缩格式将处理后的数据写入到HDFS上。主要实现代码如下:

    import org.apache.hadoop.fs.Path

    import org.apache.hadoop.io.SequenceFile.CompressionType

    import org.apache.hadoop.io.{Text, LongWritable}

    import org.apache.hadoop.mapred.{FileOutputFormat, JobConf, TextOutputFormat, TextInputFormat}

    imoprt org.apache.flink.api.scala.hadoop.mapred.HadoopOutputFormat

     

    val benv = ExecutionEnvironment.getExecutionEnvironment

    val input = benv.readHadoopFile(new TextInputFormat, classOf[LongWritable], classOf[Text], textPath)

     

    val text = input map { _._2.toString }

    val counts = text.flatMap { _.toLowerCase.split("\\W+") filter { _.nonEmpty } }

      .map { (_, 1) }

      .groupBy(0)

      .sum(1)

     

    val words = counts map { t => (new Text(t._1), new LongWritable(t._2)) }

     

    val hadoopOutputFormat = new HadoopOutputFormat[Text,LongWritable](

      new TextOutputFormat[Text, LongWritable], new JobConf)

    val c = classOf[org.apache.hadoop.io.compress.GzipCodec]

    hadoopOutputFormat.getJobConf.set("mapred.textoutputformat.separator", " ")

    hadoopOutputFormat.getJobConf.setCompressMapOutput(true)

    hadoopOutputFormat.getJobConf.set("mapred.output.compress", "true")

    hadoopOutputFormat.getJobConf.setMapOutputCompressorClass(c)

    hadoopOutputFormat.getJobConf.set("mapred.output.compression.codec", c.getCanonicalName)

    hadoopOutputFormat.getJobConf.set("mapred.output.compression.type", CompressionType.BLOCK.toString)

     

    FileOutputFormat.setOutputPath(hadoopOutputFormat.getJobConf, new Path("/tmp/iteblog/"))

     

    words.output(hadoopOutputFormat)

    benv.execute("Hadoop Compat WordCount")

    关键就是上面高亮的几行代码,然后运行上面的程序,即可以gz压缩方式将最后处理完的数据写入到HDFS上。

    展开全文
  • 循环程序设计方法 求A和B两个4字节BCD数之和 他们在内存中以压缩BCD码形式存放 ;低字节在前 高字节在后 要求结果同样形式存放SUM的单元中 data segment a db 44h,33h,22h,11h ;数A BCD数 加上后缀H b db 88h,...
    ;循环程序设计方法 求A和B两个4字节BCD数之和 他们在内存中以压缩BCD码形式存放
    ;低字节在前  高字节在后  要求结果以同样形式存放以SUM的单元中
    data segment 
        a db 44h,33h,22h,11h ;数A  BCD数 加上后缀H
        b db 88h,77h,66h,55h ;数B 格式同上
        sum db 5 dup(?)      ;存和(包含进位)
    data ends
    
    stack segment 'stack'
        stapn db 100 dup(?)
        top equ length stapn
    stack ends
    
    code segment 
     min proc far
         assume cs:code,ds:data,es:data,ss:stack;使用串操作指令要设置附加段
       start:mov ax,stack
             mov ss,ax
             mov sp,top
             push ds
             sub ax,ax
             mov ds,ax ;设置数据段
             mov es,ax ;设置附加段  与数据段相同
             mov si,offset a  ;si<数A的偏移地址
             mov bx,offset b  ;bx<数B的偏移地址
             mov di,offset sum ;di 
             mov cx,length sum ;cx 和的长度(含进位位) 为5
             dec cx ;循环次数为4 
             cld ;串操作做清方向标志 地址增量
             clc ;进位位清0
             mov ah,0 ;ah存最后一次进位 初值置0
             
        get_sum:lods a ;al 从a取一个字节 si自动增1
            adc al,[bx] ;与数B 相加 结果al
            daa ;
            inc bx 
            stos sum
            loop get_sum
            adc ah,0
            mov al,ah
            stosb 
            ret 
        main endp
        code ends
             end main

     

    展开全文
  • 哈夫曼实现文件压缩压缩(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》文件属性:

    展开全文
  • Linux压缩打包命令——tar、zip、unzip

    万次阅读 多人点赞 2019-08-16 18:39:08
    打包是指将多个文件或者目录放在一起,形成一个总的包,这样便于保存和传输,但是大小是没有变化的,压缩是指将一个或者多个大文件或者目录通过压缩算法使文件的体积变小达到压缩的目的,可以节省存储空间,在压缩...

     

    打包跟压缩的区别:

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

    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文件成功

    展开全文
  • 哈夫曼压缩与解压缩

    万次阅读 多人点赞 2018-08-13 12:52:01
    哈夫曼压缩与解压缩 目录 哈夫曼压缩与解压缩 一:引言 二:主要技术点 三:过程介绍 1、压缩: 2、解压缩 四:详细分析 一:准备过程 二:压缩 三:解压缩 五:结果演示 六:总结 七:源码地址 一:...
  • Linux之压缩压缩

    万次阅读 2019-04-15 14:41:18
    1 Linux上常见的压缩命令: (1)Linux上常见压缩文件扩展名: *.Z: compress程序压缩文件,目前使用较少。已经有gzip替换了。 *.gz: gzip程序压缩的文件。 *.bz2:bzip2程序压缩的文件,比gzip的压缩比更好。 无论...
  • tar 分卷压缩和解压缩

    千次阅读 2019-07-24 17:32:36
    示例将 jdk1.8.0_221 文件夹按 98m 进行分卷压缩和解压缩 压缩: tar -czvf - jdk1.8.0_221/ |split -b 98m - jdk1.8.0_221.tar.gz 解压缩: cat jdk1.8.0_221.tar.gza* | tar -xzv
  • web性能优化--用gzip压缩资源文件

    万次阅读 多人点赞 2019-07-31 19:14:09
    一、gzip压缩技术 gzip(GNU- ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小,这样,用户浏览页面的时候速度会快得多。gzip的压缩页面需要浏览器和服务器双方都支持,实际上就是服务器端...
  • Hadoop压缩和解压缩文件

    万次阅读 2020-04-24 12:41:41
    Hadoop压缩和解压缩文件 修改Hadoop_WordCount单词统计工程 创建CompressionTest类 package com.blu.compress; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import...
  • Linux压缩和解压缩

    千次阅读 2019-03-02 11:16:18
    它在压缩时不会占用太多CPU的,而且可以得到一个非常理想的压缩率。 tar -zcvf archive_name.tar.gz directory_to_compress --&gt;压缩一个目录 tar -zxvf archive_name.tar.gz --&gt;解压缩到当前目录下 ...
  • 求视频压缩的解决办法,原视频600m,使用工具后压缩是150m,使用七牛云压缩后变成140m,请问大神还有其他视频压缩的方法吗?我们公司需求是先下载,再播放,所以要尽量压缩到很小 大神,求解决办法
  • Linux-压缩压缩与打包解包

    万次阅读 2018-04-07 23:54:26
    一、压缩压缩 1、gzip 压缩后的文件是.gz格式 压缩:gzip 文件名 或 gzip -r 目录 解压缩:gunzip 压缩文件 或 gzip -d 压缩文件 2、zip 压缩后的文件为.zip格式(压缩、解压缩都保留原文件) 压缩:zip 压缩...
  • Centos之压缩和解压缩命令

    千次阅读 2017-11-20 18:21:17
    常用压缩格式:.zip .gz .bz2 常用压缩格式:.tar.gz .tar.bz2 zip格式压缩 zip压缩文件名 源文件 压缩文件 zip -r 压缩文件名 源目录 压缩目录 [root@localhost ~]# zip 牛牛.zip 牛牛 -...
  • 文件的压缩压缩

    千次阅读 2018-09-10 19:12:15
    背景:看到文件压缩gzip,bzip2。脑子一热,想到能不能再次压缩文件?没有百度到,想要的答案,自己费事来try try。 看不懂的知识:https://blog.csdn.net/xuchuangqi/article/details/52939705 gzip 对于要压缩...
  • 在网上调查了图片压缩的方法并实装后,大致上可以认为有两类压缩:质量压缩(不改变图片的尺寸)和尺寸压缩(相当于是像素上的压缩);质量压缩一般可用于上传大图前的处理,这样就可以节省一定的流量,毕竟现在的...
  • 在网上调查了图片压缩的方法并实装后,大致上可以认为有两类压缩:质量压缩(不改变图片的尺寸)和尺寸压缩(相当于是像素上的压缩);质量压缩一般可用于上传大图前的处理,这样就可以节省一定的流量,毕竟现在的...
  • Linux 压缩,解压缩,打包指令

    千次阅读 2017-11-17 15:39:51
    linux压缩文件扩展名有以下几种: *.Z compress程序压缩的扩展名 *.gz gzip压缩后的扩展名 *.bz2 bzip2压缩后的扩展名 *.tar tar打包后的扩展名,没有被压缩过 *.tar.gz tar打包后经过gzip压缩后的扩展名 *....
  • 将一个文件各个字符出现的次数为权值建立哈夫曼树,这样每个字符可以用从树根到该字符所在到叶子节点的路径来表示。(左为0,右为1) 压缩第二步: 哈夫曼编码有一个很重要的特性:每个字符编码不会成为另一个编码...
  • Linux中文件的压缩和解压缩

    万次阅读 2017-12-22 22:31:47
    Linux中的打包文件一般是.tar结尾的,压缩的命令一般是.gz结尾的。 而一般情况下打包和压缩是一起进行的,打包并压缩后的文件的后缀名一般.tar.gz。 命令:tar -zcvf 打包压缩后的文件名 要打包压缩的文件 ...
  • 本文采用哈夫曼编码的方式进行文件(文本文件)压缩和解压缩,首先介绍项目的整体思路:哈夫曼编码压缩文件实际就是统计出文件中各个字符出现的频率,然后为每个字符生成对应的编码,然后将每个字符用哈夫曼编码的...
  • 好用的 js 压缩工具 压缩软件 压缩程序 精简压缩 JsZIP(JavaScript压缩工具)
  • PowerShell-压缩压缩文件

    千次阅读 2019-06-25 11:47:42
    PowerShell-压缩压缩文件。本文介绍了Powershell进行压缩压缩的几种方法。附示例代码。
  • mysql innodb 表数据压缩

    千次阅读 2016-05-24 17:03:54
    记得一次面试中,面试官问我是否知道表的压缩,这个时候...表压缩可以在创建表时开启,压缩表能够使表中的数据以压缩格式存储,压缩能够显著提高原生性能和可伸缩性。压缩意味着在硬盘和内存之间传输的数据更小且占用相
  • 图像有损压缩与无损压缩Lossy and lossless compression are two kinds of data compression techniques. Here in this article, you will get to learn about what is lossy and lossless compression, their ...
  • Hadoop压缩存储方案对比

    千次阅读 2016-11-22 09:53:46
    如果数据已经以压缩的格式存储,则不需要再压缩,如jpeg。 存储格式对比: 存储格式 优点 缺点 是否可切分 建议用途 备注 GZIP 压缩率高 CPU使用率高,压缩慢 × 冷数据 BZIP2 压缩率高,部分文件格式...
  • linux下压缩、解压缩

    千次阅读 2018-12-22 22:54:41
    1. gzip *.txt : 分别对单个文件进行压缩 2.gunzip *gz : 分别对单个文件进行解压缩   bzip2: 1. bzip2 *.txt : 分别对单个文件进行压缩 2. bunzip2 *bz2 : 分别对单个文件进行解压缩 3. bzip2 -k *...
  • linux常用的压缩与解压缩命令

    千次阅读 2015-07-05 19:38:51
    1.gzip 压缩gzip 是压缩文件,压缩之后文件后缀为.gz 用法:gzip 选项 [文件]2.gunzip 解压这个命令与gzip的功能刚好相反,这个是解压。 用法 gunzip 选项 [压缩文件]3.tar这个命令可以将文件打包压缩一起执行,也...
  • Kafka压缩

    万次阅读 2017-06-14 01:17:13
    在某些情况下,整个应用的瓶颈不在于CPU或者磁盘,而是受网络带宽的影响。当然你可以选择在业务代码中对每一条消息...Kafka(本文是0.8.2.x的版本做基准的)本身可以支持几种类型的压缩,比如gzip和snappy,更高的版...
  • 索引压缩

    千次阅读 2017-08-10 16:59:27
    当待搜索的数据量极为庞大时,数据所对应的索引的...为了解决这样的问题,学者们提出了一系列的索引压缩技术。 实际上,我们所要处理的数据类型多如牛毛,根据不同的要求,为这些数据设计的索引更是千变万化,最常见
  • c#zip压缩压缩全解

    千次阅读 2017-08-12 08:47:02
    c#实现文件或文件夹的zip格式的压缩压缩。需要引入ICSharpCode.SharpZipLib.dll链接库,下载测试代码static void Main() { ZipHelper.ZipDirectory("D:\\test", "D:\\test1.zip"); //压缩文件夹,无密码 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,461,541
精华内容 584,616
关键字:

以压缩