4dkankan-utils/4dkankan-common-utils/src/main/java/com/fdkankan/common/util/FileUtil.java

package com.fdkankan.common.util;

import cn.hutool.core.collection.CollUtil;
import com.fdkankan.common.constant.ErrorCode;
import com.fdkankan.common.exception.BusinessException;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import lombok.extern.slf4j.Slf4j;

/**
 * @author MeepoGuan
 *
 * <p>Description: file_util</p>
 *
 * 2017年4月30日
 *
 */
@Slf4j
public class FileUtil {

/*	public static void main(String[] args) {
		String dirName = "d:/FH/topic/";// 创建目录
		FileUtil.createDir(dirName);
	}*/

	/**
	 * 创建目录
	 * 
	 * @param destDirName
	 *            目标目录名
	 * @return 目录创建成功返回true，否则返回false
	 */
	public static boolean createDir(String destDirName) {
		File dir = new File(destDirName);
		if (dir.exists()) {
			return false;
		}
		if (!destDirName.endsWith(File.separator)) {
			destDirName = destDirName + File.separator;
		}
		// 创建单个目录
		if (dir.mkdirs()) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 删除文件
	 * 
	 * @param filePathAndName
	 *            String 文件路径及名称 如c:/fqf.txt
	 * @return boolean
	 */
	public static void delFile(String filePathAndName) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			File myDelFile = new File(filePath);
			myDelFile.delete();

		} catch (Exception e) {
			System.out.println("删除文件操作出错");
			e.printStackTrace();

		}

	}

	/**
	 * 读取到字节数组0
	 * 
	 * @param filePath //路径
	 * @throws IOException
	 */
	public static byte[] getContent(String filePath) throws IOException {
		File file = new File(filePath);
		long fileSize = file.length();
		if (fileSize > Integer.MAX_VALUE) {
			System.out.println("file too big...");
			return null;
		}
		FileInputStream fi = new FileInputStream(file);
		byte[] buffer = new byte[(int) fileSize];
		int offset = 0;
		int numRead = 0;
		while (offset < buffer.length
				&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
			offset += numRead;
		}
		// 确保所有数据均被读取
		if (offset != buffer.length) {
			throw new IOException("Could not completely read file "
					+ file.getName());
		}
		fi.close();
		return buffer;
	}

	/**
	 * 读取到字节数组1
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray(String filePath) throws IOException {

		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
		BufferedInputStream in = null;
		try {
			in = new BufferedInputStream(new FileInputStream(f));
			int buf_size = 1024;
			byte[] buffer = new byte[buf_size];
			int len = 0;
			while (-1 != (len = in.read(buffer, 0, buf_size))) {
				bos.write(buffer, 0, len);
			}
			return bos.toByteArray();
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			bos.close();
		}
	}

	/**
	 * 读取到字节数组2
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray2(String filePath) throws IOException {

		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}

		FileChannel channel = null;
		FileInputStream fs = null;
		try {
			fs = new FileInputStream(f);
			channel = fs.getChannel();
			ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
			while ((channel.read(byteBuffer)) > 0) {
				// do nothing
				// System.out.println("reading");
			}
			return byteBuffer.array();
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				channel.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				fs.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray3(String filePath) throws IOException {

		FileChannel fc = null;
		RandomAccessFile rf = null;
		try {
			rf = new RandomAccessFile(filePath, "r");
			fc = rf.getChannel();
			MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0,
					fc.size()).load();
			//System.out.println(byteBuffer.isLoaded());
			byte[] result = new byte[(int) fc.size()];
			if (byteBuffer.remaining() > 0) {
				// System.out.println("remain");
				byteBuffer.get(result, 0, byteBuffer.remaining());
			}
			return result;
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				rf.close();
				fc.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

    public static File[] sort(File[] s) {
        //中间值
        File temp = null;
        //外循环:我认为最小的数,从0~长度-1
        for (int j = 0; j < s.length - 1; j++) {
            //最小值:假设第一个数就是最小的
            String min = s[j].getName();
            //记录最小数的下标的
            int minIndex = j;
            //内循环:拿我认为的最小的数和后面的数一个个进行比较
            for (int k = j + 1; k < s.length; k++) {
                //找到最小值
                if (Integer.parseInt(min.substring(0, min.indexOf("."))) > Integer.parseInt(s[k].getName().substring(0, s[k].getName().indexOf(".")))) {
                    //修改最小
                    min = s[k].getName();
                    minIndex = k;
                }
            }
            //当退出内层循环就找到这次的最小值
            //交换位置
            temp = s[j];
            s[j] = s[minIndex];
            s[minIndex] = temp;
        }
        return s;
    }

	/**
	 * 获取目录下所有文件
	 * @param directory
	 */
	public static List<String> getFileList(String directory) {

		File f = new File(directory);

		File[] files = f.listFiles();

		if(files == null || files.length == 0){
			return null;
		}

		List<String> list = new ArrayList<>();
		for (int i = 0; i < files.length; i++) {

			if (files[i].isFile()) {
				list.add(files[i].getAbsolutePath());
			} else {
				System.out.println("目录：" + files[i]);
				List<String> fileList = getFileList(files[i].getAbsolutePath());
				if(CollUtil.isEmpty(fileList)){
					continue;
				}
				list.addAll(fileList);
			}
		}

		return list;
	}

	/**
	 * <p>
	        zip包解压缩
	 * </p>
	 * @author dengsixing
	 * @date 2022/2/16
	 * @param inputFile 解压文件路径
	 * @param destDirPath 解压目标目录
	 **/
	public static void unZip(String inputFile,String destDirPath) throws Exception{
		File srcFile = new File(inputFile);//获取当前压缩文件
		// 判断源文件是否存在
		if (!srcFile.exists()) {
			throw new Exception("文件不存在:" + srcFile.getPath());
		}
		try(
			//创建压缩文件对象
			ZipFile zipFile = new ZipFile(srcFile, Charset.forName("GBK"))
		){
			//开始解压
			Enumeration<?> entries = zipFile.entries();
			while (entries.hasMoreElements()) {
				ZipEntry entry = (ZipEntry) entries.nextElement();
				// 如果是文件夹，就创建个文件夹
				if (entry.isDirectory()) {
					String dirPath = destDirPath + "/" + entry.getName();
					srcFile.mkdirs();
				} else {
					// 如果是文件，就先创建一个文件，然后用io流把内容copy过去
					File targetFile = new File(destDirPath + "/" + entry.getName());
					// 保证这个文件的父文件夹必须要存在
					if (!targetFile.getParentFile().exists()) {
						targetFile.getParentFile().mkdirs();
					}
					targetFile.createNewFile();
					// 将压缩文件内容写入到这个文件中
					try(InputStream is = zipFile.getInputStream(entry);
						FileOutputStream fos = new FileOutputStream(targetFile)){
						int len;
						byte[] buf = new byte[1024];
						while ((len = is.read(buf)) != -1) {
							fos.write(buf, 0, len);
						}
					}catch (IOException e){
						log.error("解压缩失败，文件名称" + entry.getName(), e);
						throw e;
					}
				}
			}
		} catch (ZipException e) {
			log.error("解压缩失败，文件路径：" + srcFile.getPath(), e);
			throw e;
		} catch (IOException e) {
			log.error("解压缩失败，文件路径：" + srcFile.getPath(), e);
			throw e;
		}
	}

	/**
	 * <p>
	        打包
	 * </p>
	 * @author dengsixing
	 * @date 2022/2/16
	 * @param inputFile
	 * @param outputFile
	 * @param withDir
	 **/
	public static void zip(String inputFile, String outputFile, boolean withDir) throws Exception {

		try(
		//创建zip输出流
			ZipOutputStream out = new ZipOutputStream(new FileOutputStream(outputFile));
			//创建缓冲输出流
			BufferedOutputStream bos = new BufferedOutputStream(out);
		){
			File input = new File(inputFile);
			compress(out, bos, input, null, withDir);
		}
	}

	/**
	 * @param name 压缩文件名，可以写为null保持默认
	 */
	//递归压缩
	public static void compress(ZipOutputStream out, BufferedOutputStream bos, File input, String name, boolean withDir) throws IOException {
		if (name == null) {
			name = input.getName();
		}
		//如果路径为目录（文件夹）
		if (input.isDirectory()) {
			//取出文件夹中的文件（或子文件夹）
			File[] flist = input.listFiles();

			if (flist.length == 0)//如果文件夹为空，则只需在目的地zip文件中写入一个目录进入
			{
				if(withDir){
					out.putNextEntry(new ZipEntry(name + "/"));
				}
			} else//如果文件夹不为空，则递归调用compress，文件夹中的每一个文件（或文件夹）进行压缩
			{
				for (int i = 0; i < flist.length; i++) {
					if(withDir){
						compress(out, bos, flist[i], name + "/" + flist[i].getName(), withDir);
					}else{
						compress(out, bos, flist[i], flist[i].getName(), withDir);
					}
				}
			}
		}
		//如果不是目录（文件夹），即为文件，则先写入目录进入点，之后将文件写入zip文件中
		else
		{
			out.putNextEntry(new ZipEntry(name));
			FileInputStream fos = new FileInputStream(input);
			BufferedInputStream bis = new BufferedInputStream(fos);
			int len;
			//将源文件写入到zip文件中
			byte[] buf = new byte[1024];
			while ((len = bis.read(buf)) != -1) {
				bos.write(buf,0,len);
			}
			bis.close();
			fos.close();
		}
	}

	public static void main(String[] args) throws Exception {


		FileUtil.unZip("F:\\test\\KJ-t-VJNe28ZImv_images_展厅全景图.zip", "F:\\test\\aaa");


	}
}