com.base4j.util.FileUtil Maven / Gradle / Ivy
The newest version!
package com.base4j.util;
import com.base4j.util.exceptions.UtilException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;
import java.net.URI;
import java.net.URL;
import java.nio.charset.Charset;
import java.text.DecimalFormat;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* 文件工具类
*
* @author xxx
*/
public class FileUtil {
private final static Logger log = LoggerFactory.getLogger(FileUtil.class);
/**
* The Unix separator character.
*/
private static final char UNIX_SEPARATOR = '/';
/**
* The Windows separator character.
*/
private static final char WINDOWS_SEPARATOR = '\\';
/**
* Class文件扩展名
*/
public static final String CLASS_EXT = ".class";
/**
* Jar文件扩展名
*/
public static final String JAR_FILE_EXT = ".jar";
/**
* 在Jar中的路径jar的扩展名形式
*/
public static final String JAR_PATH_EXT = ".jar!";
/**
* 当Path为文件形式时, path会加入一个表示文件的前缀
*/
public static final String PATH_FILE_PRE = "file:";
/**
* 列出目录文件
* 给定的绝对路径不能是压缩包中的路径
*
* @param path 目录绝对路径或者相对路径
* @return 文件列表（包含目录）
*/
public static File[] ls(String path) {
if (path == null) {
return null;
}
path = getAbsolutePath(path);
File file = file(path);
if (file.isDirectory()) {
return file.listFiles();
}
throw new UtilException(StrUtil.format("Path [{}] is not directory!", path));
}
/**
* 目录是否为空
*
* @param file 目录
* @return 是否为空，当提供非目录时，返回false
*/
public static boolean isEmpty(File file) {
if (null == file) {
return true;
}
if (file.isDirectory()) {
String[] subFiles = file.list();
if (CollectionUtil.isEmpty(subFiles)) {
return true;
}
}
return false;
}
/**
* 递归遍历目录以及子目录中的所有文件
*
* @param file 当前遍历文件
* @param fileFilter 文件过滤规则对象，选择要保留的文件
*/
public static List loopFiles(File file, FileFilter fileFilter) {
List fileList = new ArrayList();
if (file == null) {
return fileList;
} else if (file.exists() == false) {
return fileList;
}
if (file.isDirectory()) {
for (File tmp : file.listFiles()) {
fileList.addAll(loopFiles(tmp, fileFilter));
}
} else {
if (null == fileFilter || fileFilter.accept(file)) {
fileList.add(file);
}
}
return fileList;
}
/**
* 递归遍历目录以及子目录中的所有文件
*
* @param file 当前遍历文件
*/
public static List loopFiles(File file) {
return loopFiles(file, null);
}
/**
* 获得指定目录下所有文件
* 不会扫描子目录
*
* @param path 相对ClassPath的目录或者绝对路径目录
* @return 文件路径列表（如果是jar中的文件，则给定类似.jar!/xxx/xxx的路径）
* @throws IOException
*/
public static List listFileNames(String path) {
if (path == null) {
return null;
}
path = getAbsolutePath(path);
if (path.endsWith(String.valueOf(UNIX_SEPARATOR)) == false) {
path = path + UNIX_SEPARATOR;
}
List paths = new ArrayList();
int index = path.lastIndexOf(FileUtil.JAR_PATH_EXT);
try {
if (index == -1) {
// 普通目录路径
File[] files = ls(path);
for (File file : files) {
if (file.isFile()) {
paths.add(file.getName());
}
}
} else {
// jar文件中的路径
index = index + FileUtil.JAR_FILE_EXT.length();
final String jarPath = path.substring(0, index);
final String subPath = path.substring(index + 2);
for (JarEntry entry : Collections.list(new JarFile(jarPath).entries())) {
final String name = entry.getName();
if (name.startsWith(subPath)) {
String nameSuffix = StrUtil.removePrefix(name, subPath);
if (nameSuffix.contains(String.valueOf(UNIX_SEPARATOR)) == false) {
paths.add(nameSuffix);
}
}
}
}
} catch (Exception e) {
throw new UtilException(StrUtil.format("Can not read file path of [{}]", path), e);
}
return paths;
}
/**
* 创建File对象，自动识别相对或绝对路径，相对路径将自动从ClassPath下寻找
*
* @param path 文件路径
* @return File
*/
public static File file(String path) {
if (StrUtil.isBlank(path)) {
throw new NullPointerException("File path is blank!");
}
return new File(getAbsolutePath(path));
}
/**
* 创建File对象
*
* @param parent 父目录
* @param path 文件路径
* @return File
*/
public static File file(String parent, String path) {
if (StrUtil.isBlank(path)) {
throw new NullPointerException("File path is blank!");
}
return new File(parent, path);
}
/**
* 创建File对象
*
* @param parent 父文件对象
* @param path 文件路径
* @return File
*/
public static File file(File parent, String path) {
if (StrUtil.isBlank(path)) {
throw new NullPointerException("File path is blank!");
}
return new File(parent, path);
}
/**
* 创建File对象
*
* @param uri 文件URI
* @return File
*/
public static File file(URI uri) {
if (uri == null) {
throw new NullPointerException("File uri is null!");
}
return new File(uri);
}
/**
* 判断文件是否存在，如果path为null，则返回false
*
* @param path 文件路径
* @return 如果存在返回true
*/
public static boolean exist(String path) {
return (path == null) ? false : file(path).exists();
}
/**
* 判断文件是否存在，如果file为null，则返回false
*
* @param file 文件
* @return 如果存在返回true
*/
public static boolean exist(File file) {
return (file == null) ? false : file.exists();
}
/**
* 是否存在匹配文件
*
* @param directory 文件夹路径
* @param regexp 文件夹中所包含文件名的正则表达式
* @return 如果存在匹配文件返回true
*/
public static boolean exist(String directory, String regexp) {
File file = new File(directory);
if (!file.exists()) {
return false;
}
String[] fileList = file.list();
if (fileList == null) {
return false;
}
for (String fileName : fileList) {
if (fileName.matches(regexp)) {
return true;
}
}
return false;
}
/**
* 指定文件最后修改时间
*
* @param file 文件
* @return 最后修改时间
*/
public static Date lastModifiedTime(File file) {
if (!exist(file)) {
return null;
}
return new Date(file.lastModified());
}
/**
* 指定路径文件最后修改时间
*
* @param path 路径
* @return 最后修改时间
*/
public static Date lastModifiedTime(String path) {
File file = new File(path);
if (!exist(file)) {
return null;
}
return new Date(file.lastModified());
}
/**
* 创建文件，如果这个文件存在，直接返回这个文件
*
* @param fullFilePath 文件的全路径，使用POSIX风格
* @return 文件，若路径为null，返回null
* @throws IOException
*/
public static File touch(String fullFilePath) throws IOException {
if (fullFilePath == null) {
return null;
}
return touch(file(fullFilePath));
}
/**
* 创建文件，如果这个文件存在，直接返回这个文件
*
* @param file 文件对象
* @return 文件，若路径为null，返回null
* @throws IOException
*/
public static File touch(File file) throws IOException {
if (null == file) {
return null;
}
if (false == file.exists()) {
mkParentDirs(file);
file.createNewFile();
}
return file;
}
/**
* 创建所给文件或目录的父目录
*
* @param file 文件或目录
* @return 父目录
*/
public static File mkParentDirs(File file) {
final File parentFile = file.getParentFile();
if (null != parentFile) {
parentFile.mkdirs();
}
return parentFile;
}
/**
* 删除文件或者文件夹
*
* @param fullFileOrDirPath 文件或者目录的路径
* @return 成功与否
* @throws IOException
*/
public static boolean del(String fullFileOrDirPath) throws IOException {
return del(file(fullFileOrDirPath));
}
/**
* 删除文件或者文件夹
*
* @param file 文件对象
* @return 成功与否
* @throws IOException
*/
public static boolean del(File file) throws IOException {
if (file == null || file.exists() == false) {
return true;
}
if (file.isDirectory()) {
File[] files = file.listFiles();
for (File childFile : files) {
boolean isOk = del(childFile);
if (isOk == false) {
// 删除一个出错则本次删除任务失败
return false;
}
}
}
return file.delete();
}
/**
* 创建文件夹，如果存在直接返回此文件夹
*
* @param dirPath 文件夹路径，使用POSIX格式，无论哪个平台
* @return 创建的目录
*/
public static File mkdir(String dirPath) {
if (dirPath == null) {
return null;
}
File dir = file(dirPath);
if (false == dir.exists()) {
dir.mkdirs();
}
return dir;
}
/**
* 创建临时文件
* 创建后的文件名为 prefix[Randon].tmp
*
* @param dir 临时文件创建的所在目录
* @return 临时文件
* @throws IOException
*/
public static File createTempFile(File dir) throws IOException {
return createTempFile("hutool", null, dir, true);
}
/**
* 创建临时文件
* 创建后的文件名为 prefix[Randon].tmp
*
* @param dir 临时文件创建的所在目录
* @param isReCreat 是否重新创建文件（删掉原来的，创建新的）
* @return 临时文件
* @throws IOException
*/
public static File createTempFile(File dir, boolean isReCreat) throws IOException {
return createTempFile("hutool", null, dir, isReCreat);
}
/**
* 创建临时文件
* 创建后的文件名为 prefix[Randon].suffix From com.jodd.io.FileUtil
*
* @param prefix 前缀，至少3个字符
* @param suffix 后缀，如果null则使用默认.tmp
* @param dir 临时文件创建的所在目录
* @param isReCreat 是否重新创建文件（删掉原来的，创建新的）
* @return 临时文件
* @throws IOException
*/
public static File createTempFile(String prefix, String suffix, File dir, boolean isReCreat) throws IOException {
int exceptionsCount = 0;
while (true) {
try {
File file = File.createTempFile(prefix, suffix, dir).getCanonicalFile();
if (isReCreat) {
file.delete();
file.createNewFile();
}
return file;
} catch (IOException ioex) { // fixes
// java.io.WinNTFileSystem.createFileExclusively
// access denied
if (++exceptionsCount >= 50) {
throw ioex;
}
}
}
}
/**
* 复制文件或目录
* 如果目标文件为目录，则将源文件以相同文件名拷贝到目标目录
*
* @param srcPath 源文件或目录
* @param destPath 目标文件或目录
* @param isOverride 是否覆盖目标文件
* @return 目标目录或文件
* @throws IOException
*/
public static File copy(String srcPath, String destPath, boolean isOverride) throws IOException {
return copy(file(srcPath), file(destPath), isOverride);
}
/**
* 复制文件或目录
* 情况如下：
* 1、src和dest都为目录，则讲src下所有文件目录拷贝到dest下
* 2、src和dest都为文件，直接复制，名字为dest
* 3、src为文件，dest为目录，将src拷贝到dest目录下
*
* @param src 源文件
* @param dest 目标文件或目录
* @param isOverride 是否覆盖目标文件
* @return 目标目录或文件
* @throws IOException
*/
public static File copy(File src, File dest, boolean isOverride) throws IOException {
// check
if (!src.exists()) {
throw new FileNotFoundException("File not exist: " + src);
}
if (equals(src, dest)) {
throw new IOException("Files '" + src + "' and '" + dest + "' are equal");
}
// 复制目录
if (src.isDirectory()) {
if (dest.isFile()) {
throw new IOException(StrUtil.format("Src [{}] is a directory but Dest [{}] is a file!", src.getPath(), dest.getPath()));
}
if (!dest.exists()) {
dest.mkdirs();
}
String[] files = src.list();
for (String file : files) {
File srcFile = new File(src, file);
File destFile = new File(dest, file);
// 递归复制
copy(srcFile, destFile, isOverride);
}
return dest;
}
// 检查目标
if (dest.exists()) {
if (dest.isDirectory()) {
dest = new File(dest, src.getName());
}
if (false == isOverride) {
// 不覆盖，直接跳过
log.debug("File [{}] already exist", dest);
return dest;
}
} else {
touch(dest);
}
// do copy file
FileInputStream input = new FileInputStream(src);
FileOutputStream output = new FileOutputStream(dest);
try {
IoUtil.copy(input, output);
} finally {
IoUtil.close(output);
IoUtil.close(input);
}
if (src.length() != dest.length()) {
throw new IOException("Copy file failed of '" + src + "' to '" + dest + "' due to different sizes");
}
return dest;
}
/**
* 移动文件或者目录
*
* @param src 源文件或者目录
* @param dest 目标文件或者目录
* @param isOverride 是否覆盖目标
* @throws IOException
*/
public static void move(File src, File dest, boolean isOverride) throws IOException {
// check
if (!src.exists()) {
throw new FileNotFoundException("File already exist: " + src);
}
if (dest.exists()) {
if (isOverride) {
dest.delete();
} else {
log.debug("File [{}] already exist", dest);
}
}
// 来源为文件夹，目标为文件
if (src.isDirectory() && dest.isFile()) {
throw new IOException(StrUtil.format("Can not move directory [{}] to file [{}]", src, dest));
}
// 来源为文件，目标为文件夹
if (src.isFile() && dest.isDirectory()) {
dest = new File(dest, src.getName());
}
if (src.renameTo(dest) == false) {
// 在文件系统不同的情况下，renameTo会失败，此时使用copy，然后删除原文件
try {
copy(src, dest, isOverride);
src.delete();
} catch (Exception e) {
throw new IOException(StrUtil.format("Move [{}] to [{}] failed!", src, dest), e);
}
}
}
/**
* 获取绝对路径
* 此方法不会判定给定路径是否有效（文件或目录存在）
*
* @param path 相对路径
* @param baseClass 相对路径所相对的类
* @return 绝对路径
*/
public static String getAbsolutePath(String path, Class baseClass) {
if (path == null) {
path = StrUtil.EMPTY;
}
if (baseClass == null) {
return getAbsolutePath(path);
}
return StrUtil.removePrefix(PATH_FILE_PRE, baseClass.getResource(path).getPath());
}
/**
* 获取绝对路径，相对于classes的根目录
* 如果给定就是绝对路径，则返回原路径，原路径把所有\替换为/
*
* @param path 相对路径
* @return 绝对路径
*/
public static String getAbsolutePath(String path) {
if (path == null) {
path = StrUtil.EMPTY;
} else {
path = normalize(path);
if (path.startsWith("/") || path.matches("^[a-zA-Z]:/.*")) {
// 给定的路径已经是绝对路径了
return path;
}
}
// 相对路径
ClassLoader classLoader = ClassUtil.getClassLoader();
URL url = classLoader.getResource(path);
String reultPath = url != null ? url.getPath() : ClassUtil.getClassPath() + path;
return reultPath;
}
/**
* 获取标准的绝对路径
*
* @param file 文件
* @return 绝对路径
*/
public static String getAbsolutePath(File file) {
if (file == null) {
return null;
}
try {
return file.getCanonicalPath();
} catch (IOException e) {
return file.getAbsolutePath();
}
}
/**
* 判断是否为目录，如果path为null，则返回false
*
* @param path 文件路径
* @return 如果为目录true
*/
public static boolean isDirectory(String path) {
return (path == null) ? false : file(path).isDirectory();
}
/**
* 判断是否为目录，如果file为null，则返回false
*
* @param file 文件
* @return 如果为目录true
*/
public static boolean isDirectory(File file) {
return (file == null) ? false : file.isDirectory();
}
/**
* 判断是否为文件，如果path为null，则返回false
*
* @param path 文件路径
* @return 如果为文件true
*/
public static boolean isFile(String path) {
return (path == null) ? false : file(path).isDirectory();
}
/**
* 判断是否为文件，如果file为null，则返回false
*
* @param file 文件
* @return 如果为文件true
*/
public static boolean isFile(File file) {
return (file == null) ? false : file.isDirectory();
}
/**
* 检查两个文件是否是同一个文件
*
* @param file1 文件1
* @param file2 文件2
* @return 是否相同
*/
public static boolean equals(File file1, File file2) {
try {
file1 = file1.getCanonicalFile();
file2 = file2.getCanonicalFile();
} catch (IOException ignore) {
return false;
}
return file1.equals(file2);
}
/**
* 获得最后一个文件路径分隔符的位置
*
* @param filePath 文件路径
* @return 最后一个文件路径分隔符的位置
*/
public static int indexOfLastSeparator(String filePath) {
if (filePath == null) {
return -1;
}
int lastUnixPos = filePath.lastIndexOf(UNIX_SEPARATOR);
int lastWindowsPos = filePath.lastIndexOf(WINDOWS_SEPARATOR);
return (lastUnixPos >= lastWindowsPos) ? lastUnixPos : lastWindowsPos;
}
/**
* 判断文件是否被改动
* 如果文件对象为 null 或者文件不存在，被视为改动
*
* @param file 文件对象
* @param lastModifyTime 上次的改动时间
* @return 是否被改动
*/
public static boolean isModifed(File file, long lastModifyTime) {
if (null == file || false == file.exists()) {
return true;
}
return file.lastModified() != lastModifyTime;
}
/**
* 修复路径
* 1. 统一用 /
* 2. 多个 / 转换为一个
*
* @param path 原路径
* @return 修复后的路径
*/
public static String normalize(String path) {
return path.replaceAll("[/\\\\]{1,}", "/");
}
/**
* 获得相对子路径
*
* @param rootDir 绝对父路径
* @param filePath 文件路径
* @return 相对子路径
*/
public static String subPath(String rootDir, String filePath) {
return subPath(rootDir, file(filePath));
}
/**
* 获得相对子路径
*
* @param rootDir 绝对父路径
* @param file 文件
* @return 相对子路径
*/
public static String subPath(String rootDir, File file) {
if (StrUtil.isEmpty(rootDir)) {
}
String subPath = null;
try {
subPath = file.getCanonicalPath();
} catch (IOException e) {
throw new UtilException(e);
}
if (StrUtil.isNotEmpty(rootDir) && StrUtil.isNotEmpty(subPath)) {
rootDir = normalize(rootDir);
subPath = normalize(subPath);
if (subPath != null && subPath.toLowerCase().startsWith(subPath.toLowerCase())) {
subPath = subPath.substring(rootDir.length() + 1);
}
}
return subPath;
}
// --------------------------------------------------------------------------------------------
// name start
/**
* 返回主文件名
*
* @param file 文件
* @return 主文件名
*/
public static String mainName(File file) {
if (file.isDirectory()) {
return file.getName();
}
return mainName(file.getName());
}
/**
* 返回主文件名
*
* @param fileName 完整文件名
* @return 主文件名
*/
public static String mainName(String fileName) {
if (StrUtil.isBlank(fileName) || false == fileName.contains(StrUtil.DOT)) {
return fileName;
}
return StrUtil.subPre(fileName, fileName.lastIndexOf(StrUtil.DOT));
}
/**
* 获取文件扩展名
*
* @param file 文件
* @return 扩展名
*/
public static String extName(File file) {
if (null == file) {
return null;
}
if (file.isDirectory()) {
return null;
}
return extName(file.getName());
}
/**
* 获得文件的扩展名
*
* @param fileName 文件名
* @return 扩展名
*/
public static String extName(String fileName) {
if (fileName == null) {
return null;
}
int index = fileName.lastIndexOf(StrUtil.DOT);
if (index == -1) {
return StrUtil.EMPTY;
} else {
String ext = fileName.substring(index + 1);
// 扩展名中不能包含路径相关的符号
return (ext.contains(String.valueOf(UNIX_SEPARATOR)) || ext.contains(String.valueOf(WINDOWS_SEPARATOR))) ? StrUtil.EMPTY : ext;
}
}
// --------------------------------------------------------------------------------------------
// name end
// --------------------------------------------------------------------------------------------
// in start
/**
* 获得输入流
*
* @param file 文件
* @return 输入流
* @throws FileNotFoundException
*/
public static BufferedInputStream getInputStream(File file) throws FileNotFoundException {
return new BufferedInputStream(new FileInputStream(file));
}
/**
* 获得输入流
*
* @param path 文件路径
* @return 输入流
* @throws FileNotFoundException
*/
public static BufferedInputStream getInputStream(String path) throws FileNotFoundException {
return getInputStream(file(path));
}
/**
* 获得一个文件读取器
*
* @param file 文件
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedReader getUtf8Reader(File file) throws IOException {
return getReader(file, CharsetUtil.CHARSET_UTF_8);
}
/**
* 获得一个文件读取器
*
* @param path 文件路径
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedReader getUtf8Reader(String path) throws IOException {
return getReader(path, CharsetUtil.CHARSET_UTF_8);
}
/**
* 获得一个文件读取器
*
* @param file 文件
* @param charsetName 字符集
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedReader getReader(File file, String charsetName) throws IOException {
return IoUtil.getReader(getInputStream(file), charsetName);
}
/**
* 获得一个文件读取器
*
* @param file 文件
* @param charset 字符集
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedReader getReader(File file, Charset charset) throws IOException {
return IoUtil.getReader(getInputStream(file), charset);
}
/**
* 获得一个文件读取器
*
* @param path 绝对路径
* @param charsetName 字符集
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedReader getReader(String path, String charsetName) throws IOException {
return getReader(file(path), charsetName);
}
/**
* 获得一个文件读取器
*
* @param path 绝对路径
* @param charset 字符集
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedReader getReader(String path, Charset charset) throws IOException {
return getReader(file(path), charset);
}
// --------------------------------------------------------------------------------------------
// in end
/**
* 读取文件所有数据
* 文件的长度不能超过Integer.MAX_VALUE
*
* @param file 文件
* @return 字节码
* @throws IOException
*/
public static byte[] readBytes(File file) throws IOException {
// check
if (!file.exists()) {
throw new FileNotFoundException("File not exist: " + file);
}
if (!file.isFile()) {
throw new IOException("Not a file:" + file);
}
long len = file.length();
if (len >= Integer.MAX_VALUE) {
throw new IOException("File is larger then max array size");
}
byte[] bytes = new byte[(int) len];
FileInputStream in = null;
try {
in = new FileInputStream(file);
in.read(bytes);
} finally {
IoUtil.close(in);
}
return bytes;
}
/**
* 读取文件内容
*
* @param file 文件
* @return 内容
* @throws IOException
*/
public static String readUtf8String(File file) throws IOException {
return readString(file, CharsetUtil.CHARSET_UTF_8);
}
/**
* 读取文件内容
*
* @param path 文件路径
* @return 内容
* @throws IOException
*/
public static String readUtf8String(String path) throws IOException {
return readString(path, CharsetUtil.CHARSET_UTF_8);
}
/**
* 读取文件内容
*
* @param file 文件
* @param charsetName 字符集
* @return 内容
* @throws IOException
*/
public static String readString(File file, String charsetName) throws IOException {
return new String(readBytes(file), charsetName);
}
/**
* 读取文件内容
*
* @param file 文件
* @param charset 字符集
* @return 内容
* @throws IOException
*/
public static String readString(File file, Charset charset) throws IOException {
return new String(readBytes(file), charset);
}
/**
* 读取文件内容
*
* @param path 文件路径
* @param charsetName 字符集
* @return 内容
* @throws IOException
*/
public static String readString(String path, String charsetName) throws IOException {
return readString(file(path), charsetName);
}
/**
* 读取文件内容
*
* @param path 文件路径
* @param charset 字符集
* @return 内容
* @throws IOException
*/
public static String readString(String path, Charset charset) throws IOException {
return readString(file(path), charset);
}
/**
* 读取文件内容
*
* @param url 文件URL
* @param charset 字符集
* @return 内容
* @throws IOException
*/
public static String readString(URL url, String charset) throws IOException {
if (url == null) {
throw new RuntimeException("Empty url provided!");
}
InputStream in = null;
try {
in = url.openStream();
return IoUtil.read(in, charset);
} finally {
IoUtil.close(in);
}
}
/**
* 从文件中读取每一行数据
*
* @param path 文件路径
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IOException
*/
public static > T readLines(String path, String charset, T collection) throws IOException {
return readLines(file(path), charset, collection);
}
/**
* 从文件中读取每一行数据
*
* @param file 文件路径
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IOException
*/
public static > T readLines(File file, String charset, T collection) throws IOException {
BufferedReader reader = null;
try {
reader = getReader(file, charset);
String line;
while (true) {
line = reader.readLine();
if (line == null) {
break;
}
collection.add(line);
}
return collection;
} finally {
IoUtil.close(reader);
}
}
/**
* 从文件中读取每一行数据
*
* @param url 文件的URL
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IOException
*/
public static > T readLines(URL url, String charset, T collection) throws IOException {
InputStream in = null;
try {
in = url.openStream();
return IoUtil.readLines(in, charset, collection);
} finally {
IoUtil.close(in);
}
}
/**
* 从文件中读取每一行数据
*
* @param url 文件的URL
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IOException
*/
public static List readLines(URL url, String charset) throws IOException {
return readLines(url, charset, new ArrayList());
}
/**
* 从文件中读取每一行数据
*
* @param path 文件路径
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IOException
*/
public static List readLines(String path, String charset) throws IOException {
return readLines(path, charset, new ArrayList());
}
/**
* 从文件中读取每一行数据
*
* @param file 文件
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IOException
*/
public static List readLines(File file, String charset) throws IOException {
return readLines(file, charset, new ArrayList());
}
/**
* 按照给定的readerHandler读取文件中的数据
*
* @param readerHandler Reader处理类
* @param path 文件的绝对路径
* @param charset 字符集
* @return 从文件中load出的数据
* @throws IOException
*/
public static T load(ReaderHandler readerHandler, String path, String charset) throws IOException {
BufferedReader reader = null;
T result = null;
try {
reader = getReader(path, charset);
result = readerHandler.handle(reader);
} catch (IOException e) {
throw new IOException(e);
} finally {
IoUtil.close(reader);
}
return result;
}
// --------------------------------------------------------------------------------------------
// out start
/**
* 获得一个输出流对象
*
* @param file 文件
* @return 输出流对象
* @throws IOException
*/
public static BufferedOutputStream getOutputStream(File file) throws IOException {
return new BufferedOutputStream(new FileOutputStream(file));
}
/**
* 获得一个输出流对象
*
* @param path 输出到的文件路径，绝对路径
* @return 输出流对象
* @throws IOException
*/
public static BufferedOutputStream getOutputStream(String path) throws IOException {
return getOutputStream(touch(path));
}
/**
* 获得一个带缓存的写入对象
*
* @param path 输出路径，绝对路径
* @param charsetName 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedWriter getWriter(String path, String charsetName, boolean isAppend) throws IOException {
return getWriter(touch(path), Charset.forName(charsetName), isAppend);
}
/**
* 获得一个带缓存的写入对象
*
* @param path 输出路径，绝对路径
* @param charset 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedWriter getWriter(String path, Charset charset, boolean isAppend) throws IOException {
return getWriter(touch(path), charset, isAppend);
}
/**
* 获得一个带缓存的写入对象
*
* @param file 输出文件
* @param charsetName 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedWriter getWriter(File file, String charsetName, boolean isAppend) throws IOException {
return getWriter(file, Charset.forName(charsetName), isAppend);
}
/**
* 获得一个带缓存的写入对象
*
* @param file 输出文件
* @param charset 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IOException
*/
public static BufferedWriter getWriter(File file, Charset charset, boolean isAppend) throws IOException {
if (false == file.exists()) {
file.createNewFile();
}
return new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, isAppend), charset));
}
/**
* 获得一个打印写入对象，可以有print
*
* @param path 输出路径，绝对路径
* @param charset 字符集
* @param isAppend 是否追加
* @return 打印对象
* @throws IOException
*/
public static PrintWriter getPrintWriter(String path, String charset, boolean isAppend) throws IOException {
return new PrintWriter(getWriter(path, charset, isAppend));
}
/**
* 获得一个打印写入对象，可以有print
*
* @param file 文件
* @param charset 字符集
* @param isAppend 是否追加
* @return 打印对象
* @throws IOException
*/
public static PrintWriter getPrintWriter(File file, String charset, boolean isAppend) throws IOException {
return new PrintWriter(getWriter(file, charset, isAppend));
}
// --------------------------------------------------------------------------------------------
// out end
/**
* 将String写入文件，覆盖模式，字符集为UTF-8
*
* @param content 写入的内容
* @param path 文件路径
* @return 写入的文件
* @throws IOException
*/
public static File writeUtf8String(String content, String path) throws IOException {
return writeString(content, path, CharsetUtil.UTF_8);
}
/**
* 将String写入文件，覆盖模式，字符集为UTF-8
*
* @param content 写入的内容
* @param file 文件
* @return 写入的文件
* @throws IOException
*/
public static File writeUtf8String(String content, File file) throws IOException {
return writeString(content, file, CharsetUtil.UTF_8);
}
/**
* 将String写入文件，覆盖模式
*
* @param content 写入的内容
* @param path 文件路径
* @param charset 字符集
* @return 写入的文件
* @throws IOException
*/
public static File writeString(String content, String path, String charset) throws IOException {
return writeString(content, touch(path), charset);
}
/**
* 将String写入文件，覆盖模式
*
* @param content 写入的内容
* @param file 文件
* @param charset 字符集
* @throws IOException
*/
public static File writeString(String content, File file, String charset) throws IOException {
PrintWriter writer = null;
try {
writer = getPrintWriter(file, charset, false);
writer.print(content);
writer.flush();
} finally {
IoUtil.close(writer);
}
return file;
}
/**
* 将String写入文件，追加模式
*
* @param content 写入的内容
* @param path 文件路径
* @param charset 字符集
* @return 写入的文件
* @throws IOException
*/
public static File appendString(String content, String path, String charset) throws IOException {
return appendString(content, touch(path), charset);
}
/**
* 将String写入文件，追加模式
*
* @param content 写入的内容
* @param file 文件
* @param charset 字符集
* @return 写入的文件
* @throws IOException
*/
public static File appendString(String content, File file, String charset) throws IOException {
PrintWriter writer = null;
try {
writer = getPrintWriter(file, charset, true);
writer.print(content);
writer.flush();
} finally {
IoUtil.close(writer);
}
return file;
}
/**
* 将列表写入文件，覆盖模式
*
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @throws IOException
*/
public static void writeLines(Collection list, String path, String charset) throws IOException {
writeLines(list, path, charset, false);
}
/**
* 将列表写入文件，追加模式
*
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @throws IOException
*/
public static void appendLines(Collection list, String path, String charset) throws IOException {
writeLines(list, path, charset, true);
}
/**
* 将列表写入文件
*
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @param isAppend 是否追加
* @throws IOException
*/
public static void writeLines(Collection list, String path, String charset, boolean isAppend) throws IOException {
PrintWriter writer = null;
try {
writer = getPrintWriter(path, charset, isAppend);
for (T t : list) {
if (t != null) {
writer.println(t.toString());
writer.flush();
}
}
} finally {
IoUtil.close(writer);
}
}
/**
* 写数据到文件中
*
* @param data 数据
* @param path 目标文件
* @return File
* @throws IOException
*/
public static File writeBytes(byte[] data, String path) throws IOException {
return writeBytes(data, touch(path));
}
/**
* 写数据到文件中
*
* @param dest 目标文件
* @param data 数据
* @return dest
* @throws IOException
*/
public static File writeBytes(byte[] data, File dest) throws IOException {
return writeBytes(data, dest, 0, data.length, false);
}
/**
* 写入数据到文件
*
* @param data 数据
* @param dest 目标文件
* @param off
* @param len
* @param append
* @return dest
* @throws IOException
*/
public static File writeBytes(byte[] data, File dest, int off, int len, boolean append) throws IOException {
if (dest.exists() == true) {
if (dest.isFile() == false) {
throw new IOException("Not a file: " + dest);
}
}
FileOutputStream out = null;
try {
out = new FileOutputStream(dest, append);
out.write(data, off, len);
out.flush();
} finally {
IoUtil.close(out);
}
return dest;
}
/**
* 将流的内容写入文件
*
* @param dest 目标文件
* @param in 输入流
* @return dest
* @throws IOException
*/
public static File writeFromStream(InputStream in, File dest) throws IOException {
FileOutputStream out = null;
try {
out = new FileOutputStream(dest);
IoUtil.copy(in, out);
} finally {
IoUtil.close(out);
}
return dest;
}
/**
* 将流的内容写入文件
*
* @param in 输入流
* @param fullFilePath 文件绝对路径
* @return dest
* throws IOException
*/
public static File writeFromStream(InputStream in, String fullFilePath) throws IOException {
return writeFromStream(in, touch(fullFilePath));
}
/**
* 将文件写入流中
*
* @param file 文件
* @param out 流
* @throws IOException
*/
public static void writeToStream(File file, OutputStream out) throws IOException {
FileInputStream in = null;
try {
in = new FileInputStream(file);
IoUtil.copy(in, out);
} finally {
IoUtil.close(in);
}
}
/**
* 将流的内容写入文件
*
* @param fullFilePath 文件绝对路径
* @param out 输出流
* @throws IOException
*/
public static void writeToStream(String fullFilePath, OutputStream out) throws IOException {
writeToStream(touch(fullFilePath), out);
}
/**
* 可读的文件大小
*
* @param file 文件
* @return 大小
*/
public static String readableFileSize(File file) {
return readableFileSize(file.length());
}
/**
* 可读的文件大小
* 参考
* http://stackoverflow.com/questions/3263892/format-file-size-as-mb-gb-etc
*
* @param size Long类型大小
* @return 大小
*/
public static String readableFileSize(long size) {
if (size <= 0) {
return "0";
}
final String[] units = new String[]{"B", "kB", "MB", "GB", "TB", "EB"};
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
return new DecimalFormat("#,##0.##").format(size / Math.pow(1024, digitGroups)) + " " + units[digitGroups];
}
// --------------------------------------------------------------------------
// Interface start
/**
* Reader处理接口
*
* @param
* @author Luxiaolei
*/
public interface ReaderHandler {
public T handle(BufferedReader reader) throws IOException;
}
// --------------------------------------------------------------------------
// Interface end
/**
* 随机读取文件内容
*/
public static void readFileByRandomAccess(String fileName) {
RandomAccessFile randomFile = null;
try {
System.out.println("随机读取一段文件内容：");
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength > 4) ? 0 : 0;
// 将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
// 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
// 将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1) {
System.out.write(bytes, 0, byteread);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (randomFile != null) {
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
}
/**
* 随机读取文件内容
*/
public static StringBuffer readFileByRandomAccess(File file, long beginIndex, long endIndex) {
RandomAccessFile randomFile = null;
StringBuffer stringBuffer = new StringBuffer();
try {
long readLines = beginIndex;
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(file, "r");
// 文件长度，字节数
long fileLength = randomFile.length();
System.out.println("文件大小:" + fileLength);
// 读文件的起始位置
// int beginIndex = (fileLength > 4) ? 0 : 0;
// 将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[12];
int byteread = 0;
// 一次读10个字节，如果文件内容不足12个字节，则读剩下的字节。
// 将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1 && readLines < endIndex) {
readLines++;
stringBuffer.append(new String(randomFile.readLine().getBytes("ISO-8859-1"), "utf-8"));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (randomFile != null) {
try {
randomFile.close();
} catch (IOException e1) {
}
}
}
return stringBuffer;
}
/**
* 以行为单位读取文件，常用于读面向行的格式化文件
*/
public static void readFileByLines(String fileName) {
File file = new File(fileName);
BufferedReader reader = null;
try {
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader = new BufferedReader(new FileReader(file));
String tempString = null;
int line = 1;
// 一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null) {
// 显示行号
System.out.println("line " + line + ": " + tempString);
line++;
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
*/
public static void readFileByChars(String fileName) {
File file = new File(fileName);
Reader reader = null;
try {
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
int tempchar;
while ((tempchar = reader.read()) != -1) {
// 对于windows下，\r\n这两个字符在一起时，表示一个换行。
// 但如果这两个字符分开显示时，会换两次行。
// 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。
if (((char) tempchar) != '\r') {
System.out.print((char) tempchar);
}
}
reader.close();
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("\n以字符为单位读取文件内容，一次读多个字节：");
// 一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
// 读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars)) != -1) {
// 同样屏蔽掉\r不显示
if ((charread == tempchars.length) && (tempchars[tempchars.length - 1] != '\r')) {
System.out.print(tempchars);
} else {
for (int i = 0; i < charread; i++) {
if (tempchars[i] == '\r') {
continue;
} else {
System.out.print(tempchars[i]);
}
}
}
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e1) {
}
}
}
}
/**
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*/
public static void readFileByBytes(String fileName) {
File file = new File(fileName);
InputStream in = null;
try {
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
// 一次读一个字节
in = new FileInputStream(file);
int tempbyte;
while ((tempbyte = in.read()) != -1) {
System.out.println(tempbyte);
}
} catch (Exception e) {
e.printStackTrace();
}
try {
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
// 一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
FileUtil.showAvailableBytes(in);
// 读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1) {
System.out.write(tempbytes, 0, byteread);// 好方法，第一个参数是数组，第二个参数是开始位置，第三个参数是长度
}
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e1) {
}
}
}
}
/**
* 显示输入流中还剩的字节数
*/
private static void showAvailableBytes(InputStream in) {
try {
System.out.println("当前字节输入流中的字节数为:" + in.available());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
File file = new File("D:\\test.txt");
StringBuffer readFileByRandomAccess = FileUtil.readFileByRandomAccess(file, 0, 100);
System.out.println(readFileByRandomAccess.toString());
}
}