使用Java对文件或文件夹的压缩, 解压, 加密和解密

来源：互联网发布：慈溪锐智网络编辑：程序博客网时间：2024/05/16 11:07

使用zip对文件或文件夹进行压缩, 解压缩:

Java代码  
》》  使用Java对文件或文件夹的压缩, 解压, 加密和解密.  加解密类型使用的是AES.
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.util.zip.ZipEntry;  
import java.util.zip.ZipInputStream;  
import java.util.zip.ZipOutputStream;  
  
/** 
 * 对文件或文件夹进行压缩和解压 
 * 
 */  
public class ZipUtil {  
    /**得到当前系统的分隔符*/  
//  private static String separator = System.getProperty("file.separator");  
  
    /** 
     * 添加到压缩文件中 
     * @param out 
     * @param f 
     * @param base 
     * @throws Exception 
     */  
    private void directoryZip(ZipOutputStream out, File f, String base) throws Exception {  
        // 如果传入的是目录  
        if (f.isDirectory()) {  
            File[] fl = f.listFiles();  
            // 创建压缩的子目录  
            out.putNextEntry(new ZipEntry(base + "/"));  
            if (base.length() == 0) {  
                base = "";  
            } else {  
                base = base + "/";  
            }  
            for (int i = 0; i < fl.length; i++) {  
                directoryZip(out, fl[i], base + fl[i].getName());  
            }  
        } else {  
            // 把压缩文件加入rar中  
            out.putNextEntry(new ZipEntry(base));  
            FileInputStream in = new FileInputStream(f);  
            byte[] bb = new byte[10240];  
            int aa = 0;  
            while ((aa = in.read(bb)) != -1) {  
                out.write(bb, 0, aa);  
            }  
            in.close();  
        }  
    }  
  
    /** 
     * 压缩文件 
     *  
     * @param zos 
     * @param file 
     * @throws Exception 
     */  
    private void fileZip(ZipOutputStream zos, File file) throws Exception {  
        if (file.isFile()) {  
            zos.putNextEntry(new ZipEntry(file.getName()));  
            FileInputStream fis = new FileInputStream(file);  
            byte[] bb = new byte[10240];  
            int aa = 0;  
            while ((aa = fis.read(bb)) != -1) {  
                zos.write(bb, 0, aa);  
            }  
            fis.close();  
            System.out.println(file.getName());  
        } else {  
            directoryZip(zos, file, "");  
        }  
    }  
  
    /** 
     * 解压缩文件 
     *  
     * @param zis 
     * @param file 
     * @throws Exception 
     */  
    private void fileUnZip(ZipInputStream zis, File file) throws Exception {  
        ZipEntry zip = zis.getNextEntry();  
        if (zip == null)  
            return;  
        String name = zip.getName();  
        File f = new File(file.getAbsolutePath() + "/" + name);  
        if (zip.isDirectory()) {  
            f.mkdirs();  
            fileUnZip(zis, file);  
        } else {  
            f.createNewFile();  
            FileOutputStream fos = new FileOutputStream(f);  
            byte b[] = new byte[10240];  
            int aa = 0;  
            while ((aa = zis.read(b)) != -1) {  
                fos.write(b, 0, aa);  
            }  
            fos.close();  
            fileUnZip(zis, file);  
        }  
    }  
      
    /** 
     * 根据filePath创建相应的目录 
     * @param filePath 
     * @return 
     * @throws IOException 
     */  
    private File mkdirFiles(String filePath) throws IOException{  
        File file = new File(filePath);  
        if(!file.getParentFile().exists()){  
            file.getParentFile().mkdirs();  
        }  
        file.createNewFile();  
          
        return file;  
    }  
  
    /** 
     * 对zipBeforeFile目录下的文件压缩，保存为指定的文件zipAfterFile 
     *  
     * @param zipBeforeFile     压缩之前的文件 
     * @param zipAfterFile      压缩之后的文件 
     */  
    public void zip(String zipBeforeFile, String zipAfterFile) {  
        try {  
              
            ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(mkdirFiles(zipAfterFile)));  
            fileZip(zos, new File(zipBeforeFile));  
            zos.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
    /** 
     * 解压缩文件unZipBeforeFile保存在unZipAfterFile目录下 
     *  
     * @param unZipBeforeFile       解压之前的文件 
     * @param unZipAfterFile        解压之后的文件 
     */  
    public void unZip(String unZipBeforeFile, String unZipAfterFile) {  
        try {  
            ZipInputStream zis = new ZipInputStream(new FileInputStream(unZipBeforeFile));  
            File f = new File(unZipAfterFile);  
            f.mkdirs();  
            fileUnZip(zis, f);  
            zis.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  

使用AES对文件的加解密:

Java代码  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.security.Key;  
import java.security.SecureRandom;  
  
import javax.crypto.Cipher;  
import javax.crypto.KeyGenerator;  
import javax.crypto.SecretKey;  
import javax.crypto.spec.SecretKeySpec;  
  
/** 
 * 使用AES对文件进行加密和解密 
 * 
 */  
public class CipherUtil {  
    /** 
     * 使用AES对文件进行加密和解密 
     *  
     */  
    private static String type = "AES";  
  
    /** 
     * 把文件srcFile加密后存储为destFile 
     * @param srcFile     加密前的文件 
     * @param destFile    加密后的文件 
     * @param privateKey  密钥 
     * @throws GeneralSecurityException 
     * @throws IOException 
     */  
    public void encrypt(String srcFile, String destFile, String privateKey) throws GeneralSecurityException, IOException {  
        Key key = getKey(privateKey);  
        Cipher cipher = Cipher.getInstance(type + "/ECB/PKCS5Padding");  
        cipher.init(Cipher.ENCRYPT_MODE, key);  
  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        try {  
            fis = new FileInputStream(srcFile);  
            fos = new FileOutputStream(mkdirFiles(destFile));  
  
            crypt(fis, fos, cipher);  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (fis != null) {  
                fis.close();  
            }  
            if (fos != null) {  
                fos.close();  
            }  
        }  
    }  
  
    /** 
     * 把文件srcFile解密后存储为destFile 
     * @param srcFile     解密前的文件 
     * @param destFile    解密后的文件 
     * @param privateKey  密钥 
     * @throws GeneralSecurityException 
     * @throws IOException 
     */  
    public void decrypt(String srcFile, String destFile, String privateKey) throws GeneralSecurityException, IOException {  
        Key key = getKey(privateKey);  
        Cipher cipher = Cipher.getInstance(type + "/ECB/PKCS5Padding");  
        cipher.init(Cipher.DECRYPT_MODE, key);  
  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        try {  
            fis = new FileInputStream(srcFile);  
            fos = new FileOutputStream(mkdirFiles(destFile));  
  
            crypt(fis, fos, cipher);  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (fis != null) {  
                fis.close();  
            }  
            if (fos != null) {  
                fos.close();  
            }  
        }  
    }  
  
    /** 
     * 根据filePath创建相应的目录 
     * @param filePath      要创建的文件路经 
     * @return  file        文件 
     * @throws IOException 
     */  
    private File mkdirFiles(String filePath) throws IOException {  
        File file = new File(filePath);  
        if (!file.getParentFile().exists()) {  
            file.getParentFile().mkdirs();  
        }  
        file.createNewFile();  
  
        return file;  
    }  
  
    /** 
     * 生成指定字符串的密钥 
     * @param secret        要生成密钥的字符串 
     * @return secretKey    生成后的密钥 
     * @throws GeneralSecurityException 
     */  
    private static Key getKey(String secret) throws GeneralSecurityException {  
        KeyGenerator kgen = KeyGenerator.getInstance(type);  
        kgen.init(128, new SecureRandom(secret.getBytes()));  
        SecretKey secretKey = kgen.generateKey();  
        return secretKey;  
    }  
  
    /** 
     * 加密解密流 
     * @param in        加密解密前的流 
     * @param out       加密解密后的流 
     * @param cipher    加密解密 
     * @throws IOException 
     * @throws GeneralSecurityException 
     */  
    private static void crypt(InputStream in, OutputStream out, Cipher cipher) throws IOException, GeneralSecurityException {  
        int blockSize = cipher.getBlockSize() * 1000;  
        int outputSize = cipher.getOutputSize(blockSize);  
  
        byte[] inBytes = new byte[blockSize];  
        byte[] outBytes = new byte[outputSize];  
  
        int inLength = 0;  
        boolean more = true;  
        while (more) {  
            inLength = in.read(inBytes);  
            if (inLength == blockSize) {  
                int outLength = cipher.update(inBytes, 0, blockSize, outBytes);  
                out.write(outBytes, 0, outLength);  
            } else {  
                more = false;  
            }  
        }  
        if (inLength > 0)  
            outBytes = cipher.doFinal(inBytes, 0, inLength);  
        else  
            outBytes = cipher.doFinal();  
        out.write(outBytes);  
    }  
}  

对文件或文件夹进行压缩解压加密解密:

Java代码  
import java.io.File;  
import java.util.UUID;  
  
public class ZipCipherUtil {  
    /** 
     * 对目录srcFile下的所有文件目录进行先压缩后加密,然后保存为destfile 
     *  
     * @param srcFile 
     *            要操作的文件或文件夹 
     * @param destfile 
     *            压缩加密后存放的文件 
     * @param keyfile 
     *            密钥 
     */  
    public void encryptZip(String srcFile, String destfile, String keyStr) throws Exception {  
        File temp = new File(UUID.randomUUID().toString() + ".zip");  
        temp.deleteOnExit();  
        // 先压缩文件  
        new ZipUtil().zip(srcFile, temp.getAbsolutePath());  
        // 对文件加密  
        new CipherUtil().encrypt(temp.getAbsolutePath(), destfile, keyStr);  
        temp.delete();  
    }  
  
    /** 
     * 对文件srcfile进行先解密后解压缩,然后解压缩到目录destfile下 
     *  
     * @param srcfile 
     *            要解密和解压缩的文件名  
     * @param destfile 
     *            解压缩后的目录 
     * @param publicKey 
     *            密钥 
     */  
    public void decryptUnzip(String srcfile, String destfile, String keyStr) throws Exception {  
        File temp = new File(UUID.randomUUID().toString() + ".zip");  
        temp.deleteOnExit();  
        // 先对文件解密  
        new CipherUtil().decrypt(srcfile, temp.getAbsolutePath(), keyStr);  
        // 解压缩  
        new ZipUtil().unZip(temp.getAbsolutePath(),destfile);  
        temp.delete();  
    }  
      
    public static void main(String[] args) throws Exception {  
        long l1 = System.currentTimeMillis();  
          
        //加密  
//      new ZipCipherUtil().encryptZip("d:\\test\\111.jpg", "d:\\test\\photo.zip", "12345");  
        //解密  
        new ZipCipherUtil().decryptUnzip("d:\\test\\photo.zip", "d:\\test\\111_1.jpg", "12345");  
          
        long l2 = System.currentTimeMillis();  
        System.out.println((l2 - l1) + "毫秒.");  
        System.out.println(((l2 - l1) / 1000) + "秒.");  
    }  
}  
》》》使用Java对文件加密和解密
package com.copy.encrypt;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
 
 
public class FileEncryptAndDecrypt {
    /**
     * 文件file进行加密
     * @param fileUrl 文件路径
     * @param key 密码
     * @throws Exception
     */
    public static void encrypt(String fileUrl, String key) throws Exception {
        File file = new File(fileUrl);
        String path = file.getPath();
        if(!file.exists()){
            return;
        }
        int index = path.lastIndexOf("\\");
        String destFile = path.substring(0, index)+"\\"+"abc";
        File dest = new File(destFile);
        InputStream in = new FileInputStream(fileUrl);
        OutputStream out = new FileOutputStream(destFile);
        byte[] buffer = new byte[1024];
        int r;
        byte[] buffer2=new byte[1024];
        while (( r= in.read(buffer)) > 0) {
                for(int i=0;i<r;i++)
                {
                    byte b=buffer[i];
                    buffer2[i]=b==255?0:++b;
                }
                out.write(buffer2,0, r);
                out.flush();
        }
        in.close();
        out.close();
        file.delete();
        dest.renameTo(new File(fileUrl));
        appendMethodA(fileUrl, key);
        System.out.println("加密成功");
    }
     
    /**
     *
     * @param fileName
     * @param content 密钥
     */
     public static void appendMethodA(String fileName, String content) {
            try {
                // 打开一个随机访问文件流，按读写方式
                RandomAccessFile randomFile = new RandomAccessFile(fileName,"rw");
                // 文件长度，字节数
                long fileLength = randomFile.length();
                //将写文件指针移到文件尾。
                randomFile.seek(fileLength);
                randomFile.writeBytes(content);
                randomFile.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
     }
     /**
      * 解密
      * @param fileUrl 源文件
      * @param tempUrl 临时文件
      * @param ketLength 密码长度
      * @return
      * @throws Exception
      */
     public static String decrypt(String fileUrl, String tempUrl, int keyLength)throws Exception{
            File file = new File(fileUrl);
            if (!file.exists()) {
                return null;
            }
            File dest = new File(tempUrl);
            if (!dest.getParentFile().exists()) {
                dest.getParentFile().mkdirs();
            }
             
            InputStream is = new FileInputStream(fileUrl);
            OutputStream out = new FileOutputStream(tempUrl);
             
            byte[] buffer = new byte[1024];
            byte[] buffer2=new byte[1024];
            byte bMax=(byte)255;
            long size = file.length() - keyLength;
            int mod = (int) (size%1024);
            int div = (int) (size>>10);
            int count = mod==0?div:(div+1);
            int k = 1, r;
            while ((k <= count && ( r = is.read(buffer)) > 0)) {
                if(mod != 0 && k==count) {
                    r =  mod;
                }
                 
                for(int i = 0;i < r;i++)
                {
                    byte b=buffer[i];
                    buffer2[i]=b==0?bMax:--b;
                }
                out.write(buffer2,0, r);
                k++;
            }
            out.close();
            is.close();
            return tempUrl;
        }
      
     /**
      * 判断文件是否加密
      * @param fileName
      * @return
      */
     public static String readFileLastByte(String fileName, int keyLength) {
         File file = new File(fileName);
         if(!file.exists())return null;
         StringBuffer str = new StringBuffer();
            try {
                // 打开一个随机访问文件流，按读写方式
                RandomAccessFile randomFile = new RandomAccessFile(fileName,"r");
                // 文件长度，字节数
                long fileLength = randomFile.length();
                //将写文件指针移到文件尾。
                for(int i = keyLength ; i>=1 ; i--){
                    randomFile.seek(fileLength-i);
                    str.append((char)randomFile.read());
                }
                randomFile.close();
                return str.toString();
            }catch (IOException e) {
                e.printStackTrace();
            }
            return null;
         }
}

1 0