java实现调用方法解压和压缩给定的文件夹方法
1.最近接到任务，需要将压缩包解压到指定路径，还有将指定路径的文件夹压缩成一个压缩包，在网上找了一些资料，自己有完善了一下，发布出来记录一下；
引入的jar包；
<!--rar压缩-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
<version>1.9</version>
</dependency>压缩和解压方法代码：
package com.aspirecn.audit.file.biz.utils;
import org.apache.commons.compress.archivers.sevenz.SevenZArchiveEntry;
import org.apache.commons.compress.archivers.sevenz.SevenZFile;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.DigestUtils;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;
/**
* TODO
*
* @author wangyanhui
* @date 2018-07-09 13:52
*
*/
public class FileUtil {
//private static final Logger logger = LogUtil.get();
private static Logger logger = LoggerFactory.getLogger(FileUtil.class);
private static String[] SUFFIX_NAMES = {".zip", ".rar", ".7z"};
private static String ZIP = ".zip";
private static String RAR = ".rar";
private static String SEVEN_Z = ".7z";
/**
* 使用MD5编码成32位字符串
*
* @param inputStr
* @return String
*/
public static String encodeInMD5(final String inputStr) {
if (StringUtils.isEmpty(inputStr)) {
return inputStr;
}
return DigestUtils.md5DigestAsHex(inputStr.getBytes());
}
/**
* 生成存放文件路径
*
* @return path
*/
public static String generateRelativeDir() {
// 当前日期
final Date date = new Date();
// 格式化并转换String类型
final String path = new SimpleDateFormat("yyyy/MM/dd").format(date);
return path;
}
/**
* 生成FileId 例如:201806181701001+7位随机数
*
* @return fileId
*/
public static String createFileId() {
StringBuffer path = new StringBuffer();
Date date = new Date();
DateFormat format = new SimpleDateFormat("yyyyMMddHHmmssSSS");
String time = format.format(date);
path.append(time);
Random random = new Random();
int numCount = 7;
for (int i = 0; i < numCount; i++) {
path.append(String.valueOf(random.nextInt(10)));
}
return path.toString();
}
/**
* 删除指定文件
*
* @param path
*/
public static void deleteFile(final String path) {
final File file = new File(path);
if (file.exists() && file.isFile()) {
file.delete();
}
}
/**
* 删除文件夹及其下的所有子文件夹和文件
*
* @param folderPath
*/
public static void deleteFolder(String folderPath) {
try {
File baseFolder = new File(folderPath);
if (baseFolder.exists()) {
deleteAllFileInFolder(folderPath);
baseFolder.delete();
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
public static boolean deleteAllFileInFolder(String path) {
boolean flag = false;
File file = new File(path);
if (!file.exists()) {
return flag;
}
if (!file.isDirectory()) {
return flag;
}
String[] tempList = file.list();
File temp = null;
for (int i = 0; i < tempList.length; i++) {
if (path.endsWith(File.separator)) {
temp = new File(path + tempList[i]);
} else {
temp = new File(path + File.separator + tempList[i]);
}
if (temp.isFile()) {
temp.delete();
}
if (temp.isDirectory()) {
deleteAllFileInFolder(path + File.separator + tempList[i]);
deleteFolder(path + File.separator + tempList[i]);
flag = true;
}
}
return flag;
}
/**
* 移动文件（强制覆盖）
*
* @param srcFileName 源文件完整路径
* @param destDirName 目的目录完整路径
* @param originalFileName 保存的文件名称
* @return 文件移动成功返回true，否则返回false
*/
public static boolean moveFile(final String srcFileName, final String destDirName, String originalFileName) {
//源文件
final File srcFile = new File(srcFileName);
if (!srcFile.exists() || !srcFile.isFile()) {
return false;
}
//目标文件夹
final File destDir = new File(destDirName);
if (!destDir.exists()) {
destDir.mkdirs();
}
// 固定文件存放路径
return srcFile.renameTo(new File(destDirName + File.separator + originalFileName));
}
/**
* 移动文件（强制覆盖）
*
* @param srcFileName 源文件完整路径
* @param destDirName 目的目录完整路径
* @param originalFileName 保存的文件名称
* @return 文件移动成功返回true，否则返回false
*/
public static boolean moveFileForce(final String srcFileName, final String destDirName, String originalFileName) {
//源文件
final File srcFile = new File(srcFileName);
if (!srcFile.exists() || !srcFile.isFile()) {
return false;
}
//目标文件夹
final File destDir = new File(destDirName);
if (!destDir.exists()) {
destDir.mkdirs();
}
//目标文件
File desFile = new File(destDirName + File.separator + originalFileName);
//目标文件存在，且不与源文件在同一目录，删除目标文件
if (desFile.exists() && !srcFile.getPath().equals(desFile.getPath())) {
desFile.delete();
}
// 固定文件存放路径
return srcFile.renameTo(desFile);
}
/**
* 复制文件
*
* @param srcFileName
* @param destDirName
* @param originalFileName
*/
public static void copyFile(final String srcFileName, String destDirName, String originalFileName) {
final File destDir = new File(destDirName);
if (!destDir.exists()) {
destDir.mkdirs();
}
FileChannel inputChannel = null;
FileChannel outputChannel = null;
try {
inputChannel = new FileInputStream(srcFileName).getChannel();
outputChannel = new FileOutputStream(destDirName + File.separator + originalFileName).getChannel();
outputChannel.transferFrom(inputChannel, 0, inputChannel.size());
} catch (IOException e) {
logger.error(e.getMessage(), e);
} finally {
try {
inputChannel.close();
outputChannel.close();
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
}
/**
* 从http Url中下载文件
*
* @param urlStr
* @param fileName
* @param savePath
* @throws IOException
*/
public static boolean downLoadFromUrl(String urlStr, String fileName, String savePath) {
URL url = null;
HttpURLConnection conn = null;
FileOutputStream fos = null;
InputStream is = null;
try {
url = new URL(urlStr);
conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(30 * 1000);
is = conn.getInputStream();
byte[] getData;
byte[] buffer = new byte[1024];
int len = 0;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((len = is.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
getData = bos.toByteArray();
bos.close();
File saveDir = new File(savePath);
if (!saveDir.exists()) {
saveDir.mkdir();
}
File file = new File(saveDir + File.separator + fileName);
fos = new FileOutputStream(file);
fos.write(getData);
return true;
} catch (MalformedURLException e) {
logger.error(e.getMessage(), e);
} catch (IOException e) {
logger.error(e.getMessage(), e);
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
if (is != null) {
try {
is.close();
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
}
return false;
}
/**
* 解压缩zip包
*
* @param zipFilePath zip文件的全路径
* @param targetPath 解压后的文件保存的路径
* @param targetPath 解压后的文件保存的路径
* @return
*/
public static String unzip(String zipFilePath, String targetPath, boolean isInSameDir) {
StringBuffer msg = new StringBuffer();
OutputStream os = null;
InputStream is = null;
ZipFile zipFile = null;
try {
zipFile = new ZipFile(zipFilePath, Charset.forName("GBK"));
File directoryFile = new File(targetPath);
if (!directoryFile.exists()) {
directoryFile.mkdir();
}
Enumeration<?> entryEnum = zipFile.entries();
if (null != entryEnum) {
ZipEntry zipEntry = null;
int len = 4096;
String zipFileName = "";
while (entryEnum.hasMoreElements()) {
zipEntry = (ZipEntry) entryEnum.nextElement();
if (zipEntry.getSize() > 0) {
zipFileName = zipEntry.getName();
// 处理解压文件保存到同一目录
if (isInSameDir) {
if (zipFileName.indexOf("/") > -1) {
zipFileName = zipFileName.substring(zipFileName.lastIndexOf("/")+1, zipFileName.length());
if (zipFileName.startsWith("~$")) {
continue;
}
}
}
//判断文件是否已经存在。
if (checkFileExistence(targetPath, zipFileName)) {
//msg.setLength(0);
msg.append("存在重复的文件名：" + zipFileName);
}
// 文件
File targetFile = new File(targetPath + File.separator + zipFileName);
os = new BufferedOutputStream(new FileOutputStream(targetFile));
is = zipFile.getInputStream(zipEntry);
byte[] buffer = new byte[4096];
int readLen = 0;
while ((readLen = is.read(buffer, 0, len)) >= 0) {
os.write(buffer, 0, readLen);
os.flush();
}
// if (zipFileName.lastIndexOf(".") > -1) {
// String suffix = zipFileName.substring(zipFileName.lastIndexOf("."), zipFileName.length()).toLowerCase();
// if (zipFileName.lastIndexOf(".") > -1 && Arrays.asList(SUFFIX_NAMES).contains(suffix)) {
// String ret = unCompressedFilesToSameDir(targetPath + File.separator + zipFileName, targetPath, suffix);
// if (!StringUtils.isEmpty(ret)) {
// //msg.setLength(0);
// msg.append(ret);
// }
// }
// }
}
if (zipEntry.isDirectory()) {
File file = new File(targetPath + File.separator + zipEntry.getName());
if (!file.exists()) {
file.mkdir();
}
}
if (null != is) {
is.close();
}
if (null != os) {
os.close();
}
}
}
closeZipStream(zipFile, is, os);
//如果解压的文件在在目标文件夹中，将其删除
if (zipFilePath.contains(targetPath)) {
new File(zipFilePath).delete();
}
if (isInSameDir) {
String ret = moveToRootDir(targetPath);
if (!StringUtils.isEmpty(ret)) {
msg.append(ret);
}
}
if (null != directoryFile){
StringBuffer stringBuffer = unFile(directoryFile, targetPath, isInSameDir);
msg.append(stringBuffer);
}
return msg.toString();
} catch (IOException e) {
logger.error(e.getMessage(), e);
} finally {
closeZipStream(zipFile, is, os);
}
return msg.toString();
}
public static StringBuffer unFile(File sourceFile , String targetPath , boolean isInSameDir){
StringBuffer msg = new StringBuffer();
File[] sourceFiles = sourceFile.listFiles();
for (File sf : sourceFiles){
if (sf.isFile() && sf.length() > 0){
String filePath = sf.getPath();
if (filePath.lastIndexOf(".") > -1) {
//获取文件的后缀
String suffix = filePath.substring(filePath.lastIndexOf("."), filePath.length()).toLowerCase();
//如果是压缩包，继续解压缩，也就是解压到目标目录下没有rar文件位置
if (filePath.lastIndexOf(".") > -1 && Arrays.asList(SUFFIX_NAMES).contains(suffix)) {
String ret = unCompressedFilesToSameDir(filePath, targetPath, suffix);
if (!StringUtils.isEmpty(ret)) {
msg.append(ret);
}
}
}
}
if (sf.isDirectory()){
if (isInSameDir){
unFile(sf,targetPath,isInSameDir);
}else {
unFile(sf,sf.getAbsolutePath(),isInSameDir);
}
}
}
return msg;
}
/**
* 判断解压的文件在解压目录下是否存在
*
* @param targetPath
* @param zipFileName
* @return
*/
private static boolean checkFileExistence(String targetPath, String zipFileName) {
boolean exist = false;
File target = new File(targetPath);
if (target.isDirectory()) {
File[] files = target.listFiles();
for (File file : files) {
if (!file.isDirectory()) {
String fileName = file.getName();
if (fileName.equals(zipFileName)) {
exist = true;
break;
}
}
}
}
return exist;
}
/**
* 关闭zip流
*
* @param zipFile
* @param is
* @param os
*/
private static void closeZipStream(ZipFile zipFile, InputStream is, OutputStream os) {
if (null != zipFile) {
try {
zipFile.close();
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
if (null != is) {
try {
is.close();
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
if (null != os) {
try {
os.close();
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
}
/**
* 解压缩rar
*
* @param rarFilePath
* @param targetPath
* @param isInSameDir
* @return
*/
public static String unrar(String rarFilePath, String targetPath, boolean isInSameDir) {
StringBuffer msg = new StringBuffer();
OutputStream os = null;
InputStream is = null;
ZipFile zipFile = null;
try {
File rarFile = new File(rarFilePath);
//先解压到指定路径
File directoryFile = new File(targetPath);
if (!directoryFile.exists()) {
directoryFile.mkdir();
}
String cmd = "unrar X -o+ " + rarFilePath + " " + targetPath;
//解压
ShellUtil.excuete(cmd);
// 把解压后所有子目录的文件都移入目标目录
if (isInSameDir) {
String ret = moveToRootDir(targetPath);
if (!StringUtils.isEmpty(ret)) {
msg.setLength(0);
msg.append(ret);
}
}
//如果解压的文件在在目标文件夹中，将其删除
if (rarFilePath.contains(targetPath)) {
rarFile.delete();
}
//目标目录的全部文件
File folder = new File(targetPath);
File[] files = folder.listFiles();
if (null != files) {
//遍历文件夹下的所有文件
for (int i = 0; i < files.length; i++) {
File file = files[i];
//如果是文件
if (file.length() > 0) {
String filePath = file.getPath();
if (filePath.lastIndexOf(".") > -1) {
//获取文件的后缀
String suffix = filePath.substring(filePath.lastIndexOf("."), filePath.length()).toLowerCase();
//如果是压缩包，继续解压缩，也就是解压到目标目录下没有rar文件位置
if (filePath.lastIndexOf(".") > -1 && Arrays.asList(SUFFIX_NAMES).contains(suffix)) {
String ret = unCompressedFilesToSameDir(filePath, targetPath, suffix);
if (!StringUtils.isEmpty(ret)) {
msg.setLength(0);
msg.append(ret);
}
}
}
}
//如果是文件夹
if (file.isDirectory()) {
File fileFilder = new File(targetPath + File.separator + file.getName());
if (!fileFilder.exists()) {
fileFilder.mkdir();
}
}
}
}
return msg.toString();
} catch (Exception e) {
logger.error(e.getMessage(), e);
} finally {
closeZipStream(zipFile, is, os);
}
return msg.toString();
}
/**
* 移动目录下的所有文件到根目录
*
* @param filePath
*/
public static String moveToRootDir(String filePath) {
String msg = "";
List<Map<String, String>> allList = new ArrayList<>();
File baseFile = new File(filePath);
if (baseFile.isDirectory()) {
for (File file : baseFile.listFiles()) {
if (file.isDirectory()) {
getFiles(file.getAbsolutePath(), allList);
}
}
}
if (allList != null && allList.size() > 0) {
for (int i = 0; i < allList.size(); i++) {
//判断有没有重名的文件
String fileName = allList.get(i).get("fileName");
if (checkFileExistence(filePath, fileName)) {
msg = "存在重复的文件名：" + fileName;
}
FileUtil.moveFile(allList.get(i).get("filePath"), filePath, fileName);
}
}
return msg;
}
/**
* 获取一个目录下所有路径
*
* @param path
* @param mapList
* @return
*/
public static List<Map<String, String>> getFiles(String path, List<Map<String, String>> mapList) {
File file = new File(path);
Map<String, String> map = new HashMap<>(5);
// 如果这个路径是文件夹
if (file.isDirectory()) {
// 获取路径下的所有文件
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
// 如果还是文件夹 递归获取里面的文件 文件夹
if (files[i].isDirectory()) {
getFiles(files[i].getPath(), mapList);
} else {
map = new HashMap<>(5);
map.put("fileName", files[i].getName());
map.put("filePath", files[i].getAbsolutePath());
mapList.add(map);
}
}
} else {
System.out.println("文件：" + file.getPath());
}
return mapList;
}
/**
* 通过linux命令解压rar4以上版本的压缩包
*
* @param rarFilePath
* @param targetPath
*/
public static void unrarNewVersion(String rarFilePath, String targetPath) {
File saveDir = new File(targetPath);
if (!saveDir.exists()) {
saveDir.mkdir();
}
String command = "unrar X -o+ " + rarFilePath + " " + targetPath;
ShellUtil.excuete(command);
}
/**
* 解压缩7z包
*
* @param rarFilePath
* @param targetPath
* @param isInSameDir
* @return
*/
public static String unSevenZ(String rarFilePath, String targetPath, boolean isInSameDir) {
StringBuffer msg = new StringBuffer();
try {
SevenZFile sevenZFile = new SevenZFile(new File(rarFilePath));
SevenZArchiveEntry entry = sevenZFile.getNextEntry();
while (entry != null) {
if (entry.isDirectory()) {
new File(targetPath + File.separator + entry.getName()).mkdirs();
entry = sevenZFile.getNextEntry();
continue;
}
String sevenZFileName = entry.getName();
if (isInSameDir) {
if (sevenZFileName.indexOf("/") > -1) {
sevenZFileName = sevenZFileName.substring(sevenZFileName.lastIndexOf("/"), sevenZFileName.length());
if (sevenZFileName.startsWith("~$")) {
entry = sevenZFile.getNextEntry();
continue;
}
}
}
if (checkFileExistence(targetPath, sevenZFileName)) {
msg.setLength(0);
msg.append("存在重复的文件名：" + sevenZFileName);
}
FileOutputStream out = new FileOutputStream(targetPath
+ File.separator + sevenZFileName);
byte[] content = new byte[(int) entry.getSize()];
sevenZFile.read(content, 0, content.length);
out.write(content);
out.close();
entry = sevenZFile.getNextEntry();
if (sevenZFileName.lastIndexOf(".") > -1) {
String suffix = sevenZFileName.substring(sevenZFileName.lastIndexOf("."), sevenZFileName.length()).toLowerCase();
if (Arrays.asList(SUFFIX_NAMES).contains(suffix)) {
String ret = unCompressedFilesToSameDir(targetPath + File.separator + sevenZFileName, targetPath, suffix);
if (!StringUtils.isEmpty(ret)) {
msg.setLength(0);
msg.append(ret);
}
}
}
}
sevenZFile.close();
return msg.toString();
} catch (FileNotFoundException e) {
logger.error(e.getMessage(), e);
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
return msg.toString();
}
/**
* 构建目录
*
* @param outputDir 输出目录
* @param subDir 子目录
*/
public static void createDirectory(String outputDir, String subDir) {
File file = new File(outputDir);
// 子目录不为空
if (!(subDir == null || "".equals(subDir.trim()))) {
file = new File(outputDir + File.separator + subDir);
}
if (!file.exists()) {
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();
}
file.mkdirs();
}
}
/**
* 解压缩文件到同一文件夹下
* [.rar .zip .7z]
*
* @param compressedFilePath 压缩文件的路径，
* @param targetPath 解压后保存的路径
* @param suffix 压缩文件后缀名
*/
public static String unCompressedFilesToSameDir(String compressedFilePath, String targetPath, String suffix) {
String msg = "";
if (!StringUtils.isEmpty(suffix)) {
suffix = suffix.toLowerCase();
if (RAR.equals(suffix)) {
msg = FileUtil.unrar(compressedFilePath, targetPath, true);
}
if (ZIP.equals(suffix)) {
msg = FileUtil.unzip(compressedFilePath, targetPath, true);
}
if (SEVEN_Z.equals(suffix)) {
msg = FileUtil.unSevenZ(compressedFilePath, targetPath, true);
}
}
return msg;
}
public static boolean fileToZip(String sourceFilePath, String zipFilePath, String fileName) {
boolean flag = false;
File sourceFile = new File(sourceFilePath);
FileInputStream fis = null;
BufferedInputStream bis = null;
FileOutputStream fos = null;
ZipOutputStream zos = null;
if (sourceFile.exists() == false) {
System.out.println("待压缩的文件目录：" + sourceFilePath + "不存在.");
} else {
try {
File path = new File(zipFilePath);
if (path.exists() == false) {
path.mkdirs();
}
File zipFile = new File(zipFilePath + "/" + fileName + ".zip");
if (zipFile.exists()) {
System.out.println(zipFilePath + "目录下存在名字为:" + fileName + ".zip" + "打包文件.");
} else {
fos = new FileOutputStream(zipFile);
zos = new ZipOutputStream(new BufferedOutputStream(fos));
recursion(zos, sourceFile, sourceFile, fileName);
flag = true;
}
} catch (FileNotFoundException e) {
logger.error(e.getMessage(), e);
throw new RuntimeException(e);
} catch (IOException e) {
logger.error(e.getMessage(), e);
throw new RuntimeException(e);
} finally {
//关闭流
try {
if (null != bis) {
bis.close();
}
if (null != zos) {
zos.close();
}
} catch (IOException e) {
logger.error(e.getMessage(), e);
throw new RuntimeException(e);
}
}
}
return flag;
}
private static void recursion(ZipOutputStream zos, File sourceFile, File basePath, String fileName) throws IOException {
File[] sourceFiles = sourceFile.listFiles();
FileInputStream fis = null;
BufferedInputStream bis = null;
try {
if (null == sourceFiles || sourceFiles.length < 1 || null == basePath || basePath.exists() == false) {
System.out.println("待压缩的文件目录：" + sourceFile.getPath() + "里面不存在文件，无需压缩.");
} else {
byte[] bufs = new byte[1024 * 10];
for (int i = 0; i < sourceFiles.length; i++) {
File file = sourceFiles[i];
String pathName = file.getPath().substring(basePath.getPath().length()+1);;
if (file.isDirectory()){
zos.putNextEntry(new ZipEntry(pathName+"/"));
recursion(zos, file, basePath, fileName);
}else{
if (file.getName().contains(fileName)) {
logger.info("存在重复的文件名：" + file.getName());
continue;
}
//创建ZIP实体，并添加进压缩包
ZipEntry zipEntry = new ZipEntry(pathName);
zos.putNextEntry(zipEntry);
//读取待压缩的文件并写进压缩包里
int size = 1024 * 10;
fis = new FileInputStream(file);
bis = new BufferedInputStream(fis, size);
int read = 0;
while ((read = bis.read(bufs, 0, size)) != -1) {
zos.write(bufs, 0, read);
}
}
try {
if (null != fis) {
fis.close();
}
if (null != bis) {
bis.close();
}
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
}
} finally {
//关闭流
try {
if (null != fis) {
fis.close();
}
if (null != bis) {
bis.close();
}
} catch (IOException e) {
logger.error(e.getMessage(), e);
}
}
// }
}
/**
* 复制文件夹下的所有文件夹或文件到另一个文件夹
*
* @param oldPath
* @param newPath
* @throws IOException
*/
public static void copyDir(String oldPath, String newPath) throws IOException {
File file = new File(oldPath);
//文件名称列表
String[] filePath = file.list();
if (!(new File(newPath)).exists()) {
(new File(newPath)).mkdir();
}
for (int i = 0; i < filePath.length; i++) {
if ((new File(oldPath + File.separator + filePath[i])).isDirectory()) {
copyDir(oldPath + File.separator + filePath[i], newPath + File.separator + filePath[i]);
}
if (new File(oldPath + File.separator + filePath[i]).isFile()) {
copyFile(oldPath + File.separator + filePath[i], newPath + File.separator + filePath[i]);
}
}
}
public static void copyFile(String oldPath, String newPath) throws IOException {
File oldFile = new File(oldPath);
File file = new File(newPath);
FileInputStream in = new FileInputStream(oldFile);
FileOutputStream out = new FileOutputStream(file);
byte[] buffer = new byte[2097152];
while ((in.read(buffer)) != -1) {
out.write(buffer);
}
}
/**
* base64转为文件保存下来
* @param base64
* @param fileName
* @param savePath
*/
public static void base64ToFile(String base64, String fileName, String savePath) {
File file = null;
//创建文件目录
String filePath = savePath;
File dir = new File(filePath);
if (!dir.exists() && !dir.isDirectory()) {
dir.mkdirs();
}
BufferedOutputStream bos = null;
java.io.FileOutputStream fos = null;
try {
byte[] bytes = new BASE64Decoder().decodeBuffer(base64.trim());
file=new File(filePath + fileName);
fos = new java.io.FileOutputStream(file);
bos = new BufferedOutputStream(fos);
bos.write(bytes);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (bos != null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 文件转为base64字符串
* @param document
* @return
*/
public static String PDFToBase64(File document) {
BASE64Encoder encoder = new BASE64Encoder();
FileInputStream fin = null;
BufferedInputStream bin = null;
ByteArrayOutputStream baos = null;
BufferedOutputStream bout = null;
try {
fin = new FileInputStream(document);
bin = new BufferedInputStream(fin);
baos = new ByteArrayOutputStream();
bout = new BufferedOutputStream(baos);
byte[] buffer = new byte[1024];
int len = bin.read(buffer);
while (len != -1) {
bout.write(buffer, 0, len);
len = bin.read(buffer);
}
//刷新此输出流并强制写出所有缓冲的输出字节
bout.flush();
byte[] bytes = baos.toByteArray();
return encoder.encodeBuffer(bytes).trim();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fin.close();
bin.close();
bout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
public static void WriteStringToFile5(String filePath,String content) {
try {
FileOutputStream fos = new FileOutputStream(filePath);
fos.write(content.getBytes());
fos.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
// File file = new File("C:\\Users\\Desktop\\文件扫描文件.zip");
// if(file !=null) {
// String recgData = PDFToBase64(file);
// base64ToFile(recgData,"文件扫描文件.zip","D:\\test\\rar\\");
// }
//copyDir("E:\\lp", "E:\\robotcase\\test");
}
}