java 文件处理工具类

深藏阁楼爱情的钟 2022-09-14 02:19 219阅读 0赞

package com.fh.util;
    
    import java.io.BufferedInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.nio.ByteBuffer;
    import java.nio.MappedByteBuffer;
    import java.nio.channels.FileChannel;
    import java.nio.channels.FileChannel.MapMode;
    
    /**
     * 说明：文件处理
     * 作者：FH Admin
     * from：fhadmin.cn
     */
    public class FileUtil {
    
    	
    	/**获取文件大小 返回 KB 保留3位小数  没有文件时返回0
    	 * @param filepath 文件完整路径，包括文件名
    	 * @return
    	 */
    	public static Double getFilesize(String filepath){
    		File backupath = new File(filepath);
    		return Double.valueOf(backupath.length())/1000.000;
    	}
    	
    	/**
    	 * 创建目录
    	 * @param destDirName目标目录名
    	 * @return 
    	 */
    	public static Boolean createDir(String destDirName) {
    		File dir = new File(destDirName);
    		if(!dir.getParentFile().exists()){				//判断有没有父路径，就是判断文件整个路径是否存在
    			return dir.getParentFile().mkdirs();		//不存在就全部创建
    		}
    		return false;
    	}
    
    	/**
    	 * 删除文件
    	 * @param filePathAndName
    	 *            String 文件路径及名称 如c:/fqf.txt
    	 * @param fileContent
    	 *            String
    	 * @return boolean
    	 */
    	public static void delFile(String filePathAndName) {
    		try {
    			String filePath = filePathAndName;
    			filePath = filePath.toString();
    			java.io.File myDelFile = new java.io.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 filename
    	 * @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();
    			}
    		}
    	}
    
    }