精华内容
下载资源
问答
  • 删除linux 中压缩文件

    万次阅读 2018-07-11 19:52:14
    1.rm -f 压缩文件名

    1.rm -f 压缩文件名

    展开全文
  • 1.是文件夹且为空,这个没什么好说的,可以先删除文件夹里的文件删除这个文件夹;2.被别的进程占用,这不仅java能删,就算windows手动删也删了;3.跟这个文件的流没有关闭,这个是最常见的原因了然而我遇到...

    我们在用java删除文件的时候通常直接调用file.delete();方法就行了,但是很多情况下却删除不了,下面列举一些情况;

    1.是文件夹且不为空,这个没什么好说的,可以先删除文件夹里的文件再删除这个文件夹;

    2.被别的进程占用,这不仅java不能删,就算windows手动删也删不了;

    3.跟这个文件的流没有关闭,这个是最常见的原因了

    然而我遇到的是上传一个文件,然后跟这个文件有关的流也关闭了,还是删除不了,后来发现有人把这个文件偷偷的转换成zip压缩文件了。


    然后删除这个bookFile死活删除不了,如果出现这种情况,这个zipFile最后一定要close;


    java.util.zip.ZipFile.close()方法关闭ZIP文件。 关闭此ZIP文件将关闭以前由调用getInputStream()方法返回的所有输入流。这个方法连流都给我们关闭了!就不用我们手动关闭zip文件的流了,最后在调用file.delete()方法就可以删除文件了

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

    展开全文
  • 压缩文件删除源文件

    千次阅读 2018-10-24 12:35:02
    gzip * //压缩文件,并自动删除源文件。支持直接压缩目录 gzip -rv 目录名 //递归的压缩目录  下面是执行记录: [root@wx-app-160 test]# ls -lrt total 4 -rw-r--r--. 1 root root 0 Oct 24 12:14 aa.tx....

    gzip

    gzip *                          //压缩文件,并自动删除源文件。不支持直接压缩目录

    gzip -rv 目录名           //递归的压缩目录

     下面是执行记录:

    [root@wx-app-160 test]# ls -lrt
    total 4
    -rw-r--r--. 1 root root    0 Oct 24 12:14 aa.txt
    drwxr-xr-x. 2 root root 4096 Oct 24 12:16 bb
    [root@wx-app-160 test]# gzip *
    gzip: bb is a directory -- ignored
    [root@wx-app-160 test]# ll
    total 8
    -rw-r--r--. 1 root root   27 Oct 24 12:14 aa.txt.gz
    drwxr-xr-x. 2 root root 4096 Oct 24 12:16 bb

    由执行可知,压缩以后会生成一个 .gz 的文件,我们想要 .zip 的怎么办,那就使用 zip 命令。

    zip

    zip test.zip test                    //压缩 test 为 test.zip 文件

    zip test.zip test | rm -rf test  //压缩失败,并删除了 test 文件

    zip -m test.zip test               //压缩 test 为 test.zip 文件,并删除 test 文件

     

    展开全文
  • Linux中删除刚刚解压缩文件

    万次阅读 2016-10-19 16:57:18
    如果解压缩的时候目标目录写错了,导致把文件解压到了错误的目录,可以用以下命令来把解压了的文件删除掉。...实际上tar -tf 是列出该压缩文件中的文件列表 xargs rm是根据前面的文件列表来删除文件
  • 在Linux压缩/解压缩文件

    千次阅读 2018-06-14 11:09:08
    (-c打包,-v显示过程,-f指定打包后的文件名)# 解包文件tar -xvf 打包文件.tar关于后缀名是.tar.gz 的# 压缩文件tar -zcvf 打包文件.tar.gz 被压缩的文件/路径。。。(-z 压缩为.tar.gz格式)# 解压文件tar -zxvf...
  • Charset gbk = Charset.forName("GBK"); ZipFile zip = new ZipFile(new File(fileName), gbk);
  • web性能优化--用gzip压缩资源文件

    万次阅读 多人点赞 2019-07-31 19:14:09
    一、gzip压缩技术 gzip(GNU- ZIP)是一种压缩技术。...浏览器那里不需要我们担心,因为目前的大多数浏览器都支持解析gzip压缩过的资源文件。在实际的应用我们发现压缩的比率往往在3到10倍,也...
  • Android中文件压缩和解压缩

    万次阅读 2017-03-06 01:08:43
    使用场景当我们在应用的Assets目录中需要加入文件时,可以直接将源文件放入,但这样会造成打包后的apk整体过大,此时就需要将放入的文件进行压缩.又如当我们需要从服务器下载文件时,如果下载源文件耗时又消耗流量,较...
  • Linux压缩以及删除文件命令

    千次阅读 2018-11-19 16:58:36
    tar命令 ... rm -rf 文件名 可删除文件夹以及文件夹文件 rm -rf 文件名1 文件名2 可删除多个文件夹以及文件夹文件 zip命令  解压:unzip FileName.zip  压缩:zip FileName....
  • 近期在项目,需要压缩文件,同时压缩文件需要删除源文件,public static boolean fileToZip(String sourceFilePath,String zipFilePath,String zipFileName){ boolean flag = false; File sourceFile = new File...
  • python下解压缩zip文件删除文件

    千次阅读 2017-07-20 09:20:53
    利用python下载数据,下载下来的数据为zip格式,因为有上千个这样的文件,因此便直接在爬虫程序里加入了解压缩zip文件的内容,并且因为数据量较大,为了节省空间,便在解压缩后立即删除该zip文件。 先来介绍解压缩...
  • 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中文件压缩和解压缩

    万次阅读 2017-12-22 22:31:47
    (1)打包并压缩文件 Linux的打包文件一般是以.tar结尾的,压缩的命令一般是以.gz结尾的。 而一般情况下打包和压缩是一起进行的,打包并压缩后的文件的后缀名一般.tar.gz。 命令:tar -zcvf 打包压缩后的文件名 ...
  • 我们在基础(八)已经学习了压缩文件的命令,我们需要做的是把压缩命令与脚本结合起来。  linux基础(八)----linux命令系统学习----其它命令 这里以实战(四)写入文件的监控脚本为基础,加上压缩备份tar和删除原...
  • Pythonzipfile压缩文件模块的使用

    千次阅读 2018-11-01 08:45:46
    目录 zipfile ...Python zipfile 模块提供了对 zip 压缩文件的一系列操作。 f=zipfile.ZipFile("test.zip",mode="") //解压是 r , 压缩是 w 追加压缩是 a mode的几种: ...
  • python自身有一个比较好的包 tarfile以及zipfile都可以压缩文件,但是当我们需要加密压缩文件的时候,这两个包无法提供,根据官方资料 zipfile的setpassword 是无法设置密码的 ZipFile.setpassword(pwd): Set ...
  • 放入压缩包 */ for ( int i= 0 ;i length ;i++) { zos.putNextEntry( new ZipEntry(i+ ".jpg" )); FileInputStream fis = new FileInputStream(files[i]); byte [] buffer = new byte [ 1024 ]; ...
  • 文件压缩压缩

    千次阅读 2018-09-10 19:12:15
    脑子一热,想到能能再次压缩文件?没有百度到,想要的答案,自己费事来try try。 看懂的知识:https://blog.csdn.net/xuchuangqi/article/details/52939705 gzip 对于要压缩的文件,首先使用LZ77算法的一个...
  • java使用ant实现Zip文件压缩、解压缩Zip文件。 单个文件压缩成Zip文件,多个文件压缩成Zip文件。 使用ant实现大文件压缩
  • @echo off setlocal enabledelayedexpansion rem winrar安装目录,我的在D盘且目录为下 ...rem 需要压缩文件所在目录 set a=D:\dmp set c=0 for %%k in (%a%\*.sql*) do ( set /a c+=1 WinRAR a -r -ep "%~dp0%%~nk.
  •  有可能是复制的完全,压缩文件真的坏了,但也有可能是另一种情况,如在win10的系统压缩文件复制到了win7的系统,因为winrar版本差异太大导致无法解压,这时候只需要到网上下载WinRar最新版到本地,再解...
  • 网上找到的问题原因是:ZipOutputStream的流没有关闭 其实说的也没错,但是我们都知道现在的java是可以自动关闭的,如下: try( ZipOutputStream zos = new ZipOutputStream(fileOutputStream) ...
  • 文件下载 //下载单个文件 public void downloadFile(HttpServletResponse response){ String path = "D:\test\ce\1.txt" File file = new File(path); if(file.exists()){ String fil...
  • Linux tar 如何在压缩之后删除文件

    千次阅读 2019-04-20 20:59:57
    Linux tar 如何在压缩之后删除文件
  • HDFS文件压缩

    千次阅读 2018-01-26 13:52:53
    减少储存文件所需空间,还可以降低其在网络上传输的时间。 hadoop下各种压缩算法的压缩压缩算法 原始文件大小 压缩后的文件大小 压缩速度 解压速度 gzip 8.3GB 1.8GB 17.5MB/s 58MB/s bzip2 8.3GB 1.1GB 2.4MB/s
  • 在iOS使用ZipArchive压缩和解压缩文件

    热门讨论 2014-01-28 12:40:35
    一个在iOS使用ZipArchive实现压缩和解压缩文件的demo
  • 按行读取gz压缩包中文本文件的数据
  • 25_linux压缩文件,解压文件

    万次阅读 2018-07-26 09:35:42
    Linux压缩文件命令tar:将test文件夹压缩成test.tar.gz tar -czf test.tar.gz test Linux解压文件命令:将tomcat压缩包解压到当前文件夹 tar -zxvf apache-tomcat-7.0.78.tar.gz  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,035,445
精华内容 414,178
关键字:

如何删除压缩文件中不需要的文件