@ApiOperation("批量下载并打成压缩包zip格式")
@Log(title = "批量下载并打成压缩包zip格式", businessType = BusinessType.OTHER)
@PostMapping("/common/downloadZipFiles")
@ResponseBody
public void downloadFiles(HttpServletRequest request, HttpServletResponse response,@RequestBody JSONObject jsonParam) throws Exception {
ArrayList<Object> pathArray=(ArrayList)jsonParam.get("remoteDirectoryPath");
// 设置文件后缀
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String fn = "myData_" + sdf.format(new Date());
// 读取字符编码
String utf = "UTF-8";
// 设置响应
response.setContentType("application/ms-txt.numberformat:@");
response.setCharacterEncoding(utf);
response.setHeader("Pragma", "public");
response.setHeader("Cache-Control", "max-age=30");
//response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fn, utf));
response.setHeader("Content-Disposition",
"attachment;fileName=" + FileUtils.setFileDownloadHeader(request, fn+".zip"));//重新生成的新文件的名字
// 设置压缩流：直接写入response，实现边压缩边下载
ZipOutputStream zipos = null;
try {
zipos = new ZipOutputStream(new BufferedOutputStream(response.getOutputStream()));
zipos.setMethod(ZipOutputStream.DEFLATED); // 设置压缩方法
} catch (Exception e) {
e.printStackTrace();
}
//把将要下载的文件 都统一放在同一个临时文件夹下面
String filePath = geneConfig.getFileUploadPath()+fn;
for (Object pathObj:pathArray){
HashMap jsonObject=(HashMap)pathObj;
Integer type=(Integer)jsonObject.get("type");
String path=(String)jsonObject.get("path");
if (0==type){//文件夹
File file = new File(path);
CreateFileUtil.copyFolder(path,filePath+File.separator+file.getName());//复制整个文件夹内容
}else {
File file = new File(path);
CreateFileUtil.copyFile(path,filePath+File.separator+file.getName());//复制单个文件
}
}
//将合并后的文件夹下载
File sourceFile = new File(filePath);
ZipUtils.compress(sourceFile,zipos,sourceFile.getName(),true);
// 关闭流
try {
zipos.closeEntry();
zipos.close();
} catch (IOException e) {
e.printStackTrace();
}
//删除临时文件夹
//FileHandleUtil.deleteFolder(filePath);
}
package com.hessianhealth.common.utils.file;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.net.URLEncoder;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
/**
* 文件处理工具类
*
* @author lgn
*/
public class FileUtils extends org.apache.commons.io.FileUtils
{
public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\u4e00-\\u9fa5]+";
/**
* 输出指定文件的byte数组
*
* @param filePath 文件路径
* @param os 输出流
* @return
*/
public static void writeBytes(String filePath, OutputStream os) throws IOException
{
FileInputStream fis = null;
try
{
File file = new File(filePath);
if (!file.exists())
{
throw new FileNotFoundException(filePath);
}
fis = new FileInputStream(file);
byte[] b = new byte[1024];
int length;
while ((length = fis.read(b)) > 0)
{
os.write(b, 0, length);
}
}
catch (IOException e)
{
throw e;
}
finally
{
if (os != null)
{
try
{
os.close();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
if (fis != null)
{
try
{
fis.close();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
}
}
/**
* 删除文件
*
* @param filePath 文件
* @return
*/
public static boolean deleteFile(String filePath)
{
boolean flag = false;
File file = new File(filePath);
// 路径为文件且不为空则进行删除
if (file.isFile() && file.exists())
{
file.delete();
flag = true;
}
return flag;
}
/**
* 文件名称验证
*
* @param filename 文件名称
* @return true 正常 false 非法
*/
public static boolean isValidFilename(String filename)
{
return filename.matches(FILENAME_PATTERN);
}
/**
* 下载文件名重新编码
*
* @param request 请求对象
* @param fileName 文件名
* @return 编码后的文件名
*/
public static String setFileDownloadHeader(HttpServletRequest request, String fileName)
throws UnsupportedEncodingException
{
final String agent = request.getHeader("USER-AGENT");
String filename = fileName;
if (agent.contains("MSIE"))
{
// IE浏览器
filename = URLEncoder.encode(filename, "utf-8");
filename = filename.replace("+", " ");
}
else if (agent.contains("Firefox"))
{
// 火狐浏览器
filename = new String(fileName.getBytes(), "ISO8859-1");
}
else if (agent.contains("Chrome"))
{
// google浏览器
filename = URLEncoder.encode(filename, "UTF-8");
//filename=new String(filename.getBytes("UTF-8"),"UTF-8");
}
else
{
// 其它浏览器
// 万能乱码问题解决
filename = new String(fileName.getBytes("UTF-8"), "ISO-8859-1");
}
return filename;
}
/**
* 将一段错误解码的字符串重新解码
*/
public static String convertEncodingFormat(String str, String formatFrom, String FormatTo) {
String result = null;
if (!(str == null || str.length() == 0)) {
try {
result = new String(str.getBytes(formatFrom), FormatTo);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
return result;
}
/**
* 获取编码格式
* @param str
* @return
*/
public static String getEncoding(String str) {
String encode = "GB2312";
try {
if (str.equals(new String(str.getBytes(encode), encode))) { //判断是不是GB2312
String s = encode;
return s; //是的话，返回“GB2312“，以下代码同理
}
} catch (Exception exception) {
}
encode = "ISO-8859-1";
try {
if (str.equals(new String(str.getBytes(encode), encode))) { //判断是不是ISO-8859-1
String s1 = encode;
return s1;
}
} catch (Exception exception1) {
}
encode = "UTF-8";
try {
if (str.equals(new String(str.getBytes(encode), encode))) { //判断是不是UTF-8
String s2 = encode;
return s2;
}
} catch (Exception exception2) {
}
encode = "GBK";
try {
if (str.equals(new String(str.getBytes(encode), encode))) { //判断是不是GBK
String s3 = encode;
return s3;
}
} catch (Exception exception3) {
}
return ""; //如果都不是，说明输入的内容不属于常见的编码格式。
}
/**
* 获取文件夹下的所有文件名称
* @param path
* @return
*/
public static ArrayList<Object> getAllFile(String path) {
ArrayList<Object> list = new ArrayList();
File file = new File(path);//
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
File file1 = files[i];
String fileName = file1.getName();
/* String prefix = fileName.substring(fileName.lastIndexOf(".") + 1)
.toLowerCase();
if ("csv".equals(prefix)) {
list.add(fileName);
}*/
list.add(fileName);
}
return list;
}
//读取json文件
public static Object readJsonFile(File jsonFile) {
String jsonStr = "";
try {
FileReader fileReader = new FileReader(jsonFile);
Reader reader = new InputStreamReader(new FileInputStream(jsonFile),"utf-8");
int ch = 0;
StringBuffer sb = new StringBuffer();
while ((ch = reader.read()) != -1) {
sb.append((char) ch);
}
fileReader.close();
reader.close();
jsonStr = sb.toString();
JSONObject jsonObject = JSONObject.parseObject(jsonStr);
return jsonObject;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* 写出json文件
*/
public static void writeJsonFileByString(String newJsonString, String path){
try {
FileWriter fw = new FileWriter(path);
PrintWriter out = new PrintWriter(fw);
out.write(newJsonString);
out.println();
fw.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 由于遇到文件夹不查询其包含所有子文件夹、文件，因此没必要用到递归
*
* @param dirAllStrArr
* @param dirFile
* @return
* @throws Exception
*/
public static void DirAll(List<String> dirAllStrArr, File dirFile,Map map) throws Exception {
if (dirFile.exists()) {
File files[] = dirFile.listFiles();
for (File file : files) {
// 如果遇到文件夹则递归调用。
if (file.isDirectory()) {
System.out.println("-------文件夹-----"+file.getName());
// 递归调用
DirAll(dirAllStrArr, file,map);
} else {
// 如果遇到文件夹则放入数组
if (dirFile.getPath().endsWith(File.separator)) {
System.out.println("------2------"+file.getName());
dirAllStrArr.add(dirFile.getPath()+ File.separator + file.getName());
} else {
System.out.println("------文件-----"+file.getName());
dirAllStrArr.add(dirFile.getPath() + File.separator
+ file.getName());
/* boolean flay=map.containsKey(file.getName());
if (true==flay){//已存在重名文件
System.out.println("-------已存在重名文件------");
}*/
map.put(file.getName(),file.getName());
}
}
}
}
}
/**
* 获取文件夹下 所有文件夹的名称
* @param filePath
*/
private static void getFilePath(String filePath) {
File file = new File(filePath);
if (file.isDirectory()){
System.out.println("---------------:"+filePath);
File[] listFiles = file.listFiles();
for (int i = 0 ;i<listFiles.length;i++){
getFilePath(listFiles[i].getAbsolutePath());
}
}
}
public static void isDirectory(File file) {
if(file.exists()){
if (file.isFile()) {
System.out.println("file is ==>>" + file.getAbsolutePath());
}else{
File[] list = file.listFiles();
if (list.length == 0) {
System.out.println(file.getAbsolutePath() + " is null");
} else {
for (int i = 0; i < list.length; i++) {
isDirectory(list[i]);//递归调用
}
}
}
}else{
System.out.println("文件不存在！");
}
}
/*
* 函数名：getFile
* 作用：使用递归，输出指定文件夹内的所有文件
* 参数：path：文件夹路径 deep：表示文件的层次深度，控制前置空格的个数
* 前置空格缩进，显示文件层次结构
*/
private static void getFile(String path,int deep){
// 获得指定文件对象
File file = new File(path);
// 获得该文件夹内的所有文件
File[] array = file.listFiles();
for(int i=0;i<array.length;i++)
{
if(array[i].isFile())//如果是文件
{
for (int j = 0; j < deep; j++)//输出前置空格
System.out.print(" ");
// 只输出文件名字
System.out.println("1:"+ array[i].getName()+" 文件大小："+array[i].length());
// 输出当前文件的完整路径
// System.out.println("#####" + array[i]);
// 同样输出当前文件的完整路径 大家可以去掉注释 测试一下
// System.out.println(array[i].getPath());
}
else if(array[i].isDirectory())//如果是文件夹
{
for (int j = 0; j < deep; j++)//输出前置空格
System.out.print(" ");
System.out.println("2:"+ array[i].getName()+" 文件大小："+array[i].length());
//System.out.println(array[i].getPath());
//文件夹需要调用递归 ，深度+1
getFile(array[i].getPath(),deep+1);
}
}
}
/**
* 获取文件夹里面所有文件的路径
* @param path
* @return
*/
public static JSONArray getDirectoryFilesPath(String path) {
File dirFile = new File(path);
Map<String, JSONArray> map = new HashMap<>();
if (dirFile.exists()) {
File files[] = dirFile.listFiles();
for (File file : files) {
String createTime = getFileTime(file, "createTime");
String lastmodfiyTime = getFileTime(file, "lastmodfiyTime");
// 如果遇到文件夹则递归调用。
if (file.isDirectory()) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("type",0);
jsonObject.put("fileName",file.getName());
//long size=getFileSize3(file);
jsonObject.put("length", "");
jsonObject.put("createTime",createTime);
jsonObject.put("lastmodfiyTime",lastmodfiyTime);
jsonObject.put("path",dirFile.getPath()+ File.separator + file.getName());
if (map.containsKey(createTime)) {
JSONArray array = map.get(createTime);
array.add(jsonObject);
} else {
JSONArray array = new JSONArray();
array.add(jsonObject);
map.put(createTime,array);
}
// 递归调用
//DirAll(file);
} else {
// 如果遇到文件夹则放入数组
if (dirFile.getPath().endsWith(File.separator)) {
} else {
JSONObject jsonObject = new JSONObject();
jsonObject.put("type",1);
jsonObject.put("fileName",file.getName());
jsonObject.put("length",FileUtils.getPrintSize(file.length()));
jsonObject.put("createTime",createTime);
jsonObject.put("lastmodfiyTime", lastmodfiyTime);
jsonObject.put("path",dirFile.getPath() + File.separator
+ file.getName());
if (map.containsKey(createTime)) {
JSONArray array = map.get(createTime);
array.add(jsonObject);
} else {
JSONArray array = new JSONArray();
array.add(jsonObject);
map.put(createTime,array);
}
}
}
}
}
// 设置一个全局动态数组，来存放文件路径
// 主要遍历文件夹，包含所有子文件夹、文件的情况时，用到递归，所以要这样设置
JSONArray dirAllStrArr = new JSONArray();
Object[] key_arr = map.keySet().toArray();//按创建时间排序
Arrays.sort(key_arr);
for (Object key : key_arr) {
JSONArray value = map.get(key);
dirAllStrArr.addAll(value);
}
return dirAllStrArr;
}
/**
* 通过file.nio.*中的FileChannel工具来获取文件大小：
* @param file
*/
public static long getFileSize3(File file){
FileChannel fc = null;
long size=0;
try{
if(file.exists() &&file.isFile()){
String fileName =file.getName();
FileInputStream fis = new FileInputStream(file);
fc =fis.getChannel();
size=fc.size();
System.out.println("文件"+fileName+"的大小是："+fc.size()+"\n");
}
} catch(Exception e) {
e.printStackTrace();
}finally{
if(null!=fc){
try{
fc.close();
} catch(IOException e) {
e.printStackTrace();
}
}
}
return size;
}
/**
* 如何获取文件的创建时间、更新时间
* @param file
* @return
*/
public static String getFileTime(File file,String type) {
if (file == null) {
return null;
}
BasicFileAttributes attr = null;
try {
Path path = file.toPath();
attr = Files.readAttributes(path, BasicFileAttributes.class);
} catch (IOException e) {
e.printStackTrace();
}
Instant instant;
if ("createTime".equals(type)){
// 创建时间
instant = attr.creationTime().toInstant();
}else{
// 更新时间
instant = attr.lastModifiedTime().toInstant();
}
// 上次访问时间
// Instant instant = attr.lastAccessTime().toInstant();
String format = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneId.systemDefault()).format(instant);
return format;
}
/**
* 在文件处理的系统中，很容易就能通过一些系统自带的方法取出其大小，问题是这个大小往往只是一个字节数B。
如果要把这个字节数转化为KB、MB、GB的最终呈现给用户，则涉及到整除与取余的算术运算。
* @param size
* @return
*/
public static String getPrintSize(long size) {
//如果字节数少于1024，则直接以B为单位，否则先除于1024，后3位因太少无意义
if (size < 1024) {
return String.valueOf(size) + "B";
} else {
size = size / 1024;
}
//如果原字节数除于1024之后，少于1024，则可以直接以KB作为单位
//因为还没有到达要使用另一个单位的时候
//接下去以此类推
if (size < 1024) {
return String.valueOf(size) + "KB";
} else {
size = size / 1024;
}
if (size < 1024) {
//因为如果以MB为单位的话，要保留最后1位小数，
//因此，把此数乘以100之后再取余
size = size * 100;
return String.valueOf((size / 100)) + "."
+ String.valueOf((size % 100)) + "MB";
} else {
//否则如果要以GB为单位的，先除于1024再作同样的处理
size = size * 100 / 1024;
return String.valueOf((size / 100)) + "."
+ String.valueOf((size % 100)) + "GB";
}
}
/**
* 类说明：File流转为MultipartFile流
* @param file
* @return
*/
public static MultipartFile getMulFileByFile(File file) {
FileItem fileItem = createFileItem(file.getPath(),file.getName());
MultipartFile mfile = new CommonsMultipartFile(fileItem);
return mfile;
}
public static FileItem createFileItem(String filePath,String fileName){
String fieldName = "file";
FileItemFactory factory = new DiskFileItemFactory(16, null);
FileItem item = factory.createItem(fieldName, "text/plain", false,fileName);
File newfile = new File(filePath);
int bytesRead = 0;
byte[] buffer = new byte[8192];
try
{
FileInputStream fis = new FileInputStream(newfile);
OutputStream os = item.getOutputStream();
while ((bytesRead = fis.read(buffer, 0, 8192))!= -1)
{
os.write(buffer, 0, bytesRead);
}
os.close();
fis.close();
}
catch (IOException e)
{
e.printStackTrace();
}
return item;
}
/**
* 使用FileInputStream读取文件A的字节，使用FileOutputStream写入到文件B
* @param source
* @param dest
* @throws IOException
*/
public static void copyFileUsingFileStreams(File source, File dest)
throws IOException {
InputStream input = null;
OutputStream output = null;
try {
input = new FileInputStream(source);
output = new FileOutputStream(dest);
byte[] buf = new byte[1024];
int bytesRead;
while ((bytesRead = input.read(buf))!= -1) {
output.write(buf, 0, bytesRead);
}
} finally {
input.close();
output.close();
}
}
/**
* 写出json文件
*/
public static void writeJsonFile(String newJsonString, String path){
try {
FileWriter fw = new FileWriter(path);
PrintWriter out = new PrintWriter(fw);
out.write(newJsonString);
out.println();
fw.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 读取一个文本 一行一行读取
*
* @param path
* @return
* @throws IOException
*/
public static List<String> readFile02(String path) throws IOException {
// 使用一个字符串集合来存储文本中的路径 ，也可用String []数组
List<String> list = new ArrayList<String>();
FileInputStream fis = new FileInputStream(path);
// 防止路径乱码 如果utf-8 乱码 改GBK eclipse里创建的txt 用UTF-8，在电脑上自己创建的txt 用GBK
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
BufferedReader br = new BufferedReader(isr);
String line = "";
while ((line = br.readLine()) != null) {
// 如果 t x t文件里的路径 不包含---字符串 这里是对里面的内容进行一个筛选
if (line.lastIndexOf("---") < 0) {
list.add(line);
}
}
br.close();
isr.close();
fis.close();
return list;
}
/**
* 把File转化为MultipartFile过程记录
* @param file
* @return
*/
public MultipartFile fileToMultipartFile(File file) {
FileItem fileItem = createFileItem(file);
MultipartFile multipartFile = new CommonsMultipartFile(fileItem);
return multipartFile;
}
private static FileItem createFileItem(File file) {
FileItemFactory factory = new DiskFileItemFactory(16, null);
FileItem item = factory.createItem("textField", "text/plain", true, file.getName());
int bytesRead = 0;
byte[] buffer = new byte[8192];
try {
FileInputStream fis = new FileInputStream(file);
OutputStream os = item.getOutputStream();
while ((bytesRead = fis.read(buffer, 0, 8192)) != -1) {
os.write(buffer, 0, bytesRead);
}
os.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
return item;
}
public static void main(String[] args) throws Exception {
/* File dirFile = new File("C:\\Users\\liangguannan\\Desktop\\download");
// 设置一个全局动态数组，来存放文件路径
// 主要遍历文件夹，包含所有子文件夹、文件的情况时，用到递归，所以要这样设置
ArrayList<String> dirAllStrArr = new ArrayList<String>();
Map repeatMap = Maps.newHashMap();
DirAll(dirAllStrArr,dirFile,repeatMap);
System.out.println("dirAllStrArr:"+dirAllStrArr.size());
System.out.println("repeatMap:"+repeatMap.size());*/
//isDirectory(dirFile);
//getFilePath("C:\\Users\\liangguannan\\Desktop\\csv");
//这是需要获取的文件夹路径
/* String path = "C:\\Users\\liangguannan\\Desktop\\csv";
getFile(path,0);*/
/* File file = new File("C:\\Users\\liangguannan\\Desktop\\20201215120330.order.json");//
System.out.println(readJsonFile(file));
JSONObject jsonObject=(JSONObject) JSONObject.toJSON(readJsonFile(file));
jsonObject.put("GroupName","wtf");
writeJsonFile(jsonObject.toJSONString(),"C:\\Users\\liangguannan\\Desktop\\20201215120330.order.json");*/
//String fileurl="C:\\Users\\liangguannan\\Desktop\\新建文本文档.txt";
//File sourcefile = new File(fileurl);
//System.out.println("1:"+sourcefile.getParent());
/* String file="C:\\Users\\liangguannan\\Desktop\\download\\Script.1.2\\Rpicture.R";
File destfile = new File(file);
copyFileUsingFileStreams(sourcefile,destfile);*/
}
}
package com.hessianhealth.common.utils.file;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
public class ZipUtils {
private static final int BUFFER_SIZE = 2 * 1024;
/**
* 压缩成ZIP 方法 * @param srcDir 压缩文件夹路径
* @param out 压缩文件输出流
* @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构;
* false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
* @throws RuntimeException 压缩失败会抛出运行时异常
*/
public static void toZip(String srcDir, OutputStream out, boolean KeepDirStructure)
throws RuntimeException{
long start = System.currentTimeMillis();
ZipOutputStream zos = null ;
try {
zos = new ZipOutputStream(out);
File sourceFile = new File(srcDir);
compress(sourceFile,zos,sourceFile.getName(),KeepDirStructure);
long end = System.currentTimeMillis();
System.out.println("压缩完成，耗时：" + (end - start) +" ms");
} catch (Exception e) {
throw new RuntimeException("zip error from ZipUtils",e);
}finally{
if(zos != null){
try {
zos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 压缩成ZIP 方法 * @param srcFiles 需要压缩的文件列表
* @param out 压缩文件输出流
* @throws RuntimeException 压缩失败会抛出运行时异常
*/
public static void toZip(List<File> srcFiles , OutputStream out)throws RuntimeException {
long start = System.currentTimeMillis();
ZipOutputStream zos = null ;
try {
zos = new ZipOutputStream(out);
for (File srcFile : srcFiles) {
byte[] buf = new byte[BUFFER_SIZE];
zos.putNextEntry(new ZipEntry(srcFile.getName()));
int len;
FileInputStream in = new FileInputStream(srcFile);
while ((len = in.read(buf)) != -1){
zos.write(buf, 0, len);
}
zos.closeEntry();
in.close();
}
long end = System.currentTimeMillis();
System.out.println("压缩完成，耗时：" + (end - start) +" ms");
} catch (Exception e) {
throw new RuntimeException("zip error from ZipUtils",e);
}finally{
if(zos != null){
try {
zos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 递归压缩方法
* @param sourceFile 源文件
* @param zos zip输出流
* @param name 压缩后的名称
* @param KeepDirStructure 是否保留原来的目录结构,true:保留目录结构;
* false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
* @throws Exception
*/
public static void compress(File sourceFile, ZipOutputStream zos, String name,
boolean KeepDirStructure) throws Exception{
byte[] buf = new byte[BUFFER_SIZE];
if(sourceFile.isFile()){
// 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
zos.putNextEntry(new ZipEntry(name));
// copy文件到zip输出流中
int len;
FileInputStream in = new FileInputStream(sourceFile);
while ((len = in.read(buf)) != -1){
zos.write(buf, 0, len);
}
// Complete the entry
zos.closeEntry();
in.close();
} else {
//是文件夹
File[] listFiles = sourceFile.listFiles();
if(listFiles == null || listFiles.length == 0){
// 需要保留原来的文件结构时,需要对空文件夹进行处理
if(KeepDirStructure){
// 空文件夹的处理
zos.putNextEntry(new ZipEntry(name + "/"));
// 没有文件，不需要文件的copy
zos.closeEntry();
}
}else {
for (File file : listFiles) {
// 判断是否需要保留原来的文件结构
if (KeepDirStructure) {
// 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
// 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
compress(file, zos, name + "/" + file.getName(),KeepDirStructure);
} else {
compress(file, zos, file.getName(),KeepDirStructure);
}
}
}
}
}
public static void main(String[] args) throws Exception {
/** 测试压缩方法 */
FileOutputStream fos1= new FileOutputStream(new File("E:/testZip.zip"));
ZipUtils.toZip("E:/testZip", fos1,true);
/** 测试压缩方法 */
List<File> fileList = new ArrayList<>();
fileList.add(new File("D:/Java/jdk1.7.0_45_64bit/bin/jar.exe"));
fileList.add(new File("D:/Java/jdk1.7.0_45_64bit/bin/java.exe"));
FileOutputStream fos2= new FileOutputStream(new File("c:/mytest02.zip"));
ZipUtils.toZip(fileList, fos2);
}
}
package com.hessianhealth.common.utils;
/**
* Created by liangguannan on 2018/5/4.
*/
import com.alibaba.fastjson.JSONObject;
import com.hessianhealth.common.config.geneConfig;
import org.apache.commons.io.FileUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;
public class CreateFileUtil {
/**
* 获取系统路径
* @return
*/
public static String getfilePath(){
/*不同操作系统的文件创建路径*/
String filePath = getSaveFilePath(null); //存储文件的父目录位置
String fileName = null; //存储文件的父目录位置
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");//设置日期格式
String date=df.format(new Date());
fileName=filePath+date+"-"+"脑梗死KPI.xlsx";
return fileName;
}
/**
* 获取保存文件的路径
*
* @return
*/
public static String getSaveFilePath(String fileType) {
/*不同操作系统的文件创建路径*/
String filePath = null; //存储文件的父目录位置
String property = System.getProperty("os.name").toLowerCase();
System.out.println("系统名称："+property);
int indexOf = property.indexOf("windows");
if (indexOf == 0) {
/*此处为win系统*/
String userHome = System.getProperty("user.home");
filePath = userHome + "\\Desktop\\downFile\\";
createParentFile(filePath);
} else {
/*此处为Linux系统处理*/
switch(fileType){
case "image":
filePath= geneConfig.getImageUrl();
break;
default:
filePath= geneConfig.getUploadPath();
break;
}
System.out.println("路径名称："+filePath);
createParentFile(filePath);
}
return filePath;
}
/**
* 根据路径判断文件是否存在，如果不存在则创建
*
* @param filePath
*/
public static void createParentFile(String filePath) {
File file = new File(filePath);
boolean exists = file.exists();
if (exists) {
boolean directory = file.isDirectory();
if (directory) {
file.mkdir();
}
} else {
file.mkdir();
}
}
/**
* 根据文件路径名称删除文件
* @param filePath
* @return
*/
public static Boolean delFile(String filePath){
File file = new File(filePath);
if (file.exists()) {
return file.delete();
}
return null;
}
/**
* 下载文件
* @param fileName 文件名称
* @param fileData 文件的byte
* @return
*/
public static ResponseEntity<byte[]> downLoadFile(String fileName, byte[] fileData) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
try {
headers.setContentDispositionFormData("attachment", new String(fileName.getBytes("utf-8"), "ISO8859-1"));
return new ResponseEntity<>(fileData,headers, HttpStatus.CREATED);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* 传入文件完整路径+文件名称，进行下载
* 在Controller中直接调用即可
*
* @param fileName
* @return
*/
public static ResponseEntity<byte[]> downLoadFile(String fileName) {
File file = new File(fileName);
if (!file.exists()) {
System.out.println("-------downLoadFile---------"+"文件不存在");
return null;
}
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
try {
headers.setContentDispositionFormData("attachment", new String(file.getName().getBytes("utf-8"), "ISO8859-1"));
return new ResponseEntity<>(FileUtils.readFileToByteArray(file),
headers, HttpStatus.CREATED);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* 生成.json格式文件
*/
public static boolean createJsonFile(String jsonString, String filePath, String fileName) {
// 标记文件生成是否成功
boolean flag = true;
// 拼接文件完整路径
String fullPath = filePath + File.separator + fileName + ".json";
// 生成json格式文件
try {
// 保证创建一个新文件
File file = new File(fullPath);
if (!file.getParentFile().exists()) { // 如果父目录不存在，创建父目录
file.getParentFile().mkdirs();
}
if (file.exists()) { // 如果已存在,删除旧文件
file.delete();
}
file.createNewFile();
// 格式化json字符串
jsonString = JsonFormatTool.formatJson(jsonString);
// 将格式化后的字符串写入文件
Writer write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
write.write(jsonString);
write.flush();
write.close();
} catch (Exception e) {
flag = false;
e.printStackTrace();
}
// 返回是否成功的标记
return flag;
}
/**
* 创建txt 文件
* @return
*/
public static void createTxtFile(List<Map<String, String>> contentList, String filePath, String fileName) throws IOException {
// 拼接文件完整路径
String fullPath1 = filePath + File.separator + fileName + "_temp.txt";//生成一个临时文件
String fullPath = filePath + File.separator + fileName + ".txt";//标准路径
// 保证创建一个新文件
File filenameShip = new File(fullPath1);
if (!filenameShip.getParentFile().exists()) { // 如果父目录不存在，创建父目录
filenameShip.getParentFile().mkdirs();
}
if (filenameShip.exists()) { // 如果已存在,删除旧文件
filenameShip.delete();
}
// 先读取原有文件内容，然后进行写入操作
String readStr = "\t";//标题以tab 分割
FileWriter writer = null;
for (int i = 0; i < contentList.size(); i++) {
HashMap<String, String> map=(HashMap<String, String>) contentList.get(i);
String filein1 = "\r\n" ;
for (int j = 0; j < map.size()-1; j++) {
filein1+=map.get((1+j)+"")+ readStr;
}
filein1+=map.get((map.size())+"");
filein1+="\r\n";
try {
writer = new FileWriter(filenameShip, true);
writer.write(filein1);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
}
}
readLocalFile(fullPath1,fullPath,contentList.size());
}
/**
* 用Java实现去除文本文件中的空行
* @param fullPath1
* @param fullPath
* @param size
*/
public static void readLocalFile(String fullPath1, String fullPath, int size){
String filename1=fullPath1;//该文件有大量的空行
String filename2=fullPath;//filename1文件被去除空行后，放入文件filename2中
File file=new File(filename1);
InputStream is=null;
BufferedReader br = null;
String tmp;
FileWriter writer=null;
int i=0;
try {
is=new BufferedInputStream(new FileInputStream(file));
br = new BufferedReader(new InputStreamReader(is, "utf-8"));
writer = new FileWriter(filename2, true);
while((tmp=br.readLine())!=null){
if(tmp.equals(""));
else{
if (i ==(size-1)){//从0开始遍历
writer.write(tmp);//去除最后一行的空格
}else {
writer.write(tmp+"\n");
i++;
}
}
}
writer.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
File filenameShip = new File(fullPath1);//删除临时文件
filenameShip.delete();
}
public static void readLocalFile111(String[] args){
String line=null;
int i=0;
File file=new File(args[0]);//用命令行参数直接写入待处理文件
File file1=new File(args[1]);
//判断输入的是否是TXT文档，不是则提示退出
if(args[0].endsWith("txt")&args[1].endsWith("txt"))
{
//判断输入的文档是否存在，不存在则提示退出
if(!file.exists())
{
System.out.println("文件不存在！");
System.exit(0);
}
//输入的是TXT文档则继续往下执行
try
{
Runtime.getRuntime().exec("notepad "+args[0]);//打开待处理文件
//读出文档数据流方式
InputStreamReader Stream=new InputStreamReader(new FileInputStream(file),"UTF-8");//读入数据流方式设为‘UTF-8’，避免乱码
//构造一个字符流的缓存器，存放在控制台输入的字节转换后成的字符
BufferedReader reader=new BufferedReader(Stream);
//写入数据流方式
OutputStreamWriter outStream=new OutputStreamWriter(new FileOutputStream(file1),"UTF-8");
BufferedWriter writer=new BufferedWriter(outStream);
//以行读出文档内容至结束
while((line=reader.readLine())!=null)
{
if(line.equals(""))//判断是否是空行
{
continue;//是空行则不进行操作
}
else
{
i++;
writer.write("["+i+"]");//可在文档中标出行号
writer.write(line+"\r\n");//将非空白行写入新文档
}
}
//关闭数据流
writer.close();
reader.close();
System.out.println("修改完成！");
}
catch(Exception e)
{
e.printStackTrace();
}
try{
//打开修改后的文档
Runtime.getRuntime().exec("notepad "+args[1]);
}
catch(Exception e)
{
e.printStackTrace();
}
}
else
{
System.out.println("输入错误！（非.txt）");
System.exit(0);//退出程序
}
}
/**
* 通过本地文件访问json并读取
* @param path：E:/svn/05.Hospital/templatedept_uuid.json
* @return：json文件的内容
*/
public static String ReadFile(String path){
String laststr="";
File file=new File(path);// 打开文件
BufferedReader reader=null;
try{
FileInputStream in = new FileInputStream(file);
reader=new BufferedReader(new InputStreamReader(in,"UTF-8"));// 读取文件
String tempString=null;
while((tempString=reader.readLine())!=null){
laststr=laststr+tempString;
}
reader.close();
}catch(IOException e){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOException el){
}
}
}
return laststr;
}
/**
* 读取某个文件夹下的所有文件
*/
public static List<JSONObject> readfile(String filepath) throws FileNotFoundException, IOException {
List<JSONObject> list= new ArrayList();
try {
File file = new File(filepath);
if (!file.isDirectory()) {
System.out.println("文件");
System.out.println("path=" + file.getPath());
System.out.println("absolutepath=" + file.getAbsolutePath());
System.out.println("name=" + file.getName());
} else if (file.isDirectory()) {
System.out.println("文件夹");
String[] filelist = file.list();
for (int i = 0; i < filelist.length; i++) {
File readfile = new File(filepath + "\\" + filelist[i]);
if (!readfile.isDirectory()) {
System.out.println("path=" + readfile.getPath()+"========="+readfile.getName());
JSONObject jsonObject = new JSONObject();
jsonObject.put("path",readfile.getPath());
jsonObject.put("name",readfile.getName());
//getAllItems(readfile.getPath(),readfile.getName());
list.add(jsonObject);
} else if (readfile.isDirectory()) {
readfile(filepath + "\\" + filelist[i]);
}
}
}
} catch (FileNotFoundException e) {
System.out.println("readfile() Exception:" + e.getMessage());
}
return list;
}
/**
* 去除txt中的空行
*
*/
public static void qukonghang () {
String filename1="C:\\home\\data\\config\\20210908163757\\20210908163757_rename.txt";
String filename2="C:\\home\\data\\config\\20210908163757\\20210908163757_rename1234.txt";
File file=new File(filename1);
InputStream is=null;
BufferedReader br = null;
String tmp;
FileWriter writer=null;
int i=0;
try {
is=new BufferedInputStream(new FileInputStream(file));
br = new BufferedReader(new InputStreamReader(is, "utf-8"));
writer = new FileWriter(filename2, true);
while((tmp=br.readLine())!=null){
System.out.println(i+"-----:"+tmp.trim());
if(tmp.trim().equals(""));
else{
if (i ==2){
writer.write(tmp);
}else {
writer.write(tmp+"\n");
i++;
}
}
}
writer.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 直接读取txt的最后一行
* @param file
* @param charset
* @return
* @throws IOException
*/
public static String readLastLine(File file, String charset) throws IOException {
if (!file.exists() || file.isDirectory() || !file.canRead()) {
return null;
}
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(file, "r");
long len = raf.length();
if (len == 0L) {
return "";
} else {
long pos = len - 1;
while (pos > 0) {
pos--;
raf.seek(pos);
if (raf.readByte() == '\n') {
break;
}
}
if (pos == 0) {
raf.seek(0);
}
byte[] bytes = new byte[(int) (len - pos)];
raf.read(bytes);
if (charset == null) {
return new String(bytes);
} else {
return new String(bytes, charset);
}
}
} catch (FileNotFoundException e) {
} finally {
if (raf != null) {
try {
raf.close();
} catch (Exception e2) {
}
}
}
return null;
}
/**
* 循环创建新文件
* @param filePath
* @return
*/
public static void createNewFile( String filePath)throws IOException {
File checkFile = new File(filePath);
try {
// 二、检查目标文件是否存在，不存在则创建
if (!checkFile.getParentFile().exists()) {
checkFile.getParentFile().mkdirs();// 创建多级目标文件
}
if (!checkFile.exists()) {
checkFile.createNewFile();//创建文件
}else {
checkFile.delete();
checkFile.createNewFile();//创建文件
}
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* 复制单个文件
* @param oldPath String 原文件路径 如：c:/fqf.txt
* @param newPath String 复制后路径 如：f:/fqf.txt
* @return boolean
*/
public static void copyFile(String oldPath, String newPath) {
try {
int bytesum = 0;
int byteread = 0;
File oldfile = new File(oldPath);
if (oldfile.exists()) { //文件存在时
File file = new File(newPath);
if (!file.exists()){//如果文件不存在
createNewFile(newPath);
}
InputStream inStream = new FileInputStream(oldPath); //读入原文件
FileOutputStream fs = new FileOutputStream(newPath);
byte[] buffer = new byte[1444];
int length;
while ( (byteread = inStream.read(buffer)) != -1) {
bytesum += byteread; //字节数 文件大小
System.out.println(bytesum);
fs.write(buffer, 0, byteread);
}
inStream.close();
}
}
catch (Exception e) {
System.out.println("复制单个文件操作出错");
e.printStackTrace();
}
}
/**
* 复制整个文件夹内容
* @param oldPath String 原文件路径 如：c:/fqf
* @param newPath String 复制后路径 如：f:/fqf/ff
* @return boolean
*/
public static void copyFolder(String oldPath, String newPath) {
try {
(new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹
File a=new File(oldPath);
String[] file=a.list();
File temp=null;
for (int i = 0; i < file.length; i++) {
if(oldPath.endsWith(File.separator)){
temp=new File(oldPath+file[i]);
}
else{
temp=new File(oldPath+File.separator+file[i]);
}
if(temp.isFile()){
FileInputStream input = new FileInputStream(temp);
FileOutputStream output = new FileOutputStream(newPath + "/" +
(temp.getName()).toString());
byte[] b = new byte[1024 * 5];
int len;
while ( (len = input.read(b)) != -1) {
output.write(b, 0, len);
}
output.flush();
output.close();
input.close();
}
if(temp.isDirectory()){//如果是子文件夹
copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
}
}
}
catch (Exception e) {
System.out.println("复制整个文件夹内容操作出错");
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
qukonghang();
/* String filePath ="C:\\Users\\liangguannan\\Desktop";
// 标题
List<Map<String, String>> list2 = new ArrayList<Map<String, String>>();
HashMap<String, String> map = new HashMap<String, String>();
map.put("1", "序号");
map.put("2", "姓名");
list2.add(map);
// 内容
List<Map<String, String>> dataList = new ArrayList<Map<String, String>>();
Map<String, String> dataMap = new HashMap<String, String>();
dataMap.put("num", "1");
dataMap.put("name", "张三");
dataList.add(dataMap);
dataMap = new HashMap<String, String>();
dataMap.put("num", "2");
dataMap.put("name", "李四");
dataList.add(dataMap);
for (Map<String, String> m : dataList) {
HashMap<String, String> map2 = new HashMap<String, String>();
map2.put("1", m.get("num"));
map2.put("2", m.get("name"));
list2.add(map2);
}
createTxtFile(list2, filePath,"pro");*/
} catch (Exception e) {
e.printStackTrace();
}
}
}
版权声明：本文为u010797364原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。