Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.xiaoleilu.hutool.io.FileUtil Maven / Gradle / Ivy
package com.xiaoleilu.hutool.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URI;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.file.CopyOption;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import com.xiaoleilu.hutool.io.file.FileCopier;
import com.xiaoleilu.hutool.io.file.FileReader;
import com.xiaoleilu.hutool.io.file.FileReader.ReaderHandler;
import com.xiaoleilu.hutool.io.file.FileWriter;
import com.xiaoleilu.hutool.io.file.LineSeparator;
import com.xiaoleilu.hutool.lang.Assert;
import com.xiaoleilu.hutool.util.ArrayUtil;
import com.xiaoleilu.hutool.util.CharsetUtil;
import com.xiaoleilu.hutool.util.ClassUtil;
import com.xiaoleilu.hutool.util.CollectionUtil;
import com.xiaoleilu.hutool.util.StrUtil;
import com.xiaoleilu.hutool.util.URLUtil;
/**
* 文件工具类
*
* @author xiaoleilu
*
*/
public final class FileUtil {
private FileUtil() {
}
/** 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 = URLUtil.FILE_URL_PREFIX;
/**
* 是否为Windows环境
*
* @return 是否为Windows环境
* @since 3.0.9
*/
public static boolean isWindows() {
return '\\' == File.separatorChar;
}
/**
* 列出目录文件 dirStream = Files.newDirectoryStream(dirPath)) {
return false == dirStream.iterator().hasNext();
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
/**
* 目录是否为空
*
* @param dir 目录
* @return 是否为空
*/
public static boolean isDirEmpty(File dir) {
return isDirEmpty(dir.toPath());
}
/**
* 递归遍历目录以及子目录中的所有文件 loopFiles(File file, FileFilter fileFilter) {
List fileList = new ArrayList();
if (null == file) {
return fileList;
} else if (false == file.exists()) {
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 当前遍历文件
* @return 文件列表
*/
public static List loopFiles(File file) {
return loopFiles(file, null);
}
/**
* 获得指定目录下所有文件 listFileNames(String path) throws IORuntimeException {
if (path == null) {
return null;
}
path = getAbsolutePath(path);
if (false == path.endsWith(String.valueOf(UNIX_SEPARATOR))) {
path = path + UNIX_SEPARATOR;
}
List paths = new ArrayList();
int index = path.lastIndexOf(FileUtil.JAR_PATH_EXT);
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();
JarFile jarFile = null;
try {
jarFile = new JarFile(path.substring(0, index));
final String subPath = path.substring(index + 2);
for (JarEntry entry : Collections.list(jarFile.entries())) {
final String name = entry.getName();
if (name.startsWith(subPath)) {
final String nameSuffix = StrUtil.removePrefix(name, subPath);
if (nameSuffix.contains(String.valueOf(UNIX_SEPARATOR)) == false) {
paths.add(nameSuffix);
}
}
}
} catch (IOException e) {
throw new IORuntimeException(StrUtil.format("Can not read file path of [{}]", path), e);
} finally {
IoUtil.close(jarFile);
}
}
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);
}
/**
* 创建File对象
*
* @param url 文件URL
* @return File
*/
public static File file(URL url) {
return new File(URLUtil.toURI(url));
}
/**
* 判断文件是否存在，如果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) {
return lastModifiedTime(new File(path));
}
/**
* 计算目录或文件的总大小
* 1、src和dest都为目录，则将src目录及其目录下所有文件目录拷贝到dest下
* 2、src和dest都为文件，直接复制，名字为dest
* 3、src为文件，dest为目录，将src拷贝到dest目录下
*
*
* @param src 源文件
* @param dest 目标文件或目录，目标不存在会自动创建（目录、文件都创建）
* @param isOverride 是否覆盖目标文件
* @return 目标目录或文件
* @throws IORuntimeException IO异常
*/
public static File copy(File src, File dest, boolean isOverride) throws IORuntimeException {
return FileCopier.create(src, dest).setOverride(isOverride).copy();
}
/**
* 复制文件或目录
* 1、src和dest都为目录，则讲src下所有文件目录拷贝到dest下
* 2、src和dest都为文件，直接复制，名字为dest
* 3、src为文件，dest为目录，将src拷贝到dest目录下
*
*
* @param src 源文件
* @param dest 目标文件或目录，目标不存在会自动创建（目录、文件都创建）
* @param isOverride 是否覆盖目标文件
* @return 目标目录或文件
* @throws IORuntimeException IO异常
*/
public static File copyContent(File src, File dest, boolean isOverride) {
return FileCopier.create(src, dest).setCopyContentIfDir(true).setOverride(isOverride).copy();
}
/**
* 移动文件或者目录
*
* @param src 源文件或者目录
* @param dest 目标文件或者目录
* @param isOverride 是否覆盖目标，只有目标为文件才覆盖
* @throws IORuntimeException IO异常
*/
public static void move(File src, File dest, boolean isOverride) throws IORuntimeException {
// check
if (false == src.exists()) {
throw new IORuntimeException("File not found: " + src);
}
// 来源为文件夹，目标为文件
if (src.isDirectory() && dest.isFile()) {
throw new IORuntimeException(StrUtil.format("Can not move directory [{}] to file [{}]", src, dest));
}
if (isOverride && dest.isFile()) {// 只有目标为文件的情况下覆盖之
dest.delete();
}
// 来源为文件，目标为文件夹
if (src.isFile() && dest.isDirectory()) {
dest = new File(dest, src.getName());
}
if (false == src.renameTo(dest)) {
// 在文件系统不同的情况下，renameTo会失败，此时使用copy，然后删除原文件
try {
copy(src, dest, isOverride);
src.delete();
} catch (Exception e) {
throw new IORuntimeException(StrUtil.format("Move [{}] to [{}] failed!", src, dest), e);
}
}
}
/**
* 修改文件或目录的文件名，不变更路径，只是简单修改文件名
* FileUtil.rename(file, "aaa", true) xx/xx.png =》xx/aaa.png
*
*
* 2、isRetainExt为false时，不保留原扩展名，需要在newName中
*
*
* FileUtil.rename(file, "aaa.jpg", false) xx/xx.png =》xx/aaa.jpg
*
*
* @param file 被修改的文件
* @param newName 新的文件名，包括扩展名
* @param isRetainExt 是否保留原文件的扩展名，如果保留，则newName不需要加扩展名
* @param isOverride 是否覆盖目标文件
* @return 目标文件
* @since 3.0.9
*/
public static File rename(File file, String newName, boolean isRetainExt, boolean isOverride) {
if (isRetainExt) {
newName = newName.concat(".").concat(FileUtil.extName(file));
}
final Path path = file.toPath();
final CopyOption[] options = isOverride ? new CopyOption[] { StandardCopyOption.REPLACE_EXISTING } : new CopyOption[] {};
try {
return Files.move(path, path.resolveSibling(newName), options).toFile();
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
/**
* 获取绝对路径
* 1. 统一用 /
* 2. 多个 / 转换为一个 /
* 3. 去除两边空格
* 4. .. 和 . 转换为绝对路径，当..多于已有路径时，直接返回根路径
*
*
* 栗子：
*
* "/foo//" =》 "/foo/"
* "/foo/./" =》 "/foo/"
* "/foo/../bar" =》 "/bar"
* "/foo/../bar/" =》 "/bar/"
* "/foo/../bar/../baz" =》 "/baz"
* "/../" =》 "/"
* "foo/bar/.." =》 "foo"
* "foo/../bar" =》 "bar"
* "foo/../../bar" =》 "bar"
* "//server/foo/../bar" =》 "/server/bar"
* "//server/../bar" =》 "/bar"
* "C:\\foo\\..\\bar" =》 "C:/bar"
* "C:\\..\\bar" =》 "C:/bar"
* "~/foo/../bar/" =》 "~/bar/"
* "~/../bar" =》 "bar"
*
*
* @param path 原路径
* @return 修复后的路径
*/
public static String normalize(String path) {
if (path == null) {
return null;
}
String pathToUse = path.replaceAll("[/\\\\]{1,}", "/").trim();
int prefixIndex = pathToUse.indexOf(StrUtil.COLON);
String prefix = "";
if (prefixIndex > -1) {
prefix = pathToUse.substring(0, prefixIndex + 1);
if (false == prefix.contains("/")) {
pathToUse = pathToUse.substring(prefixIndex + 1);
}
}
if (pathToUse.startsWith(StrUtil.SLASH)) {
prefix += StrUtil.SLASH;
pathToUse = pathToUse.substring(1);
}
List pathList = StrUtil.split(pathToUse, StrUtil.C_SLASH);
List pathElements = new LinkedList();
int tops = 0;
String element;
for (int i = pathList.size() - 1; i >= 0; i--) {
element = pathList.get(i);
if (StrUtil.DOT.equals(element)) {
// 当前目录，丢弃
} else if (StrUtil.DOUBLE_DOT.equals(element)) {
tops++;
} else {
if (tops > 0) {
// Merging path element with element corresponding to top path.
tops--;
} else {
// Normal path element found.
pathElements.add(0, element);
}
}
}
return prefix + CollectionUtil.join(pathElements, StrUtil.SLASH);
}
/**
* 获得相对子路径
*
* @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 IORuntimeException(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
/**
* 判断文件路径是否有指定后缀，忽略大小写null
* @throws IORuntimeException IO异常
*/
public static String getType(File file) {
try {
return FileTypeUtil.getType(file);
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
/**
* 获取文件属性
*
* @param path 文件路径{@link Path}
* @param isFollowLinks 是否跟踪到软链对应的真实路径
* @return {@link BasicFileAttributes}
* @throws IORuntimeException IO异常
* @since 3.1.0
*/
public static BasicFileAttributes getAttributes(Path path, boolean isFollowLinks) throws IORuntimeException {
if (null == path) {
return null;
}
final LinkOption[] options = isFollowLinks ? new LinkOption[0] : new LinkOption[] { LinkOption.NOFOLLOW_LINKS };
try {
return Files.readAttributes(path, BasicFileAttributes.class, options);
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
// -------------------------------------------------------------------------------------------- in start
/**
* 获得输入流
*
* @param file 文件
* @return 输入流
* @throws IORuntimeException 文件未找到
*/
public static BufferedInputStream getInputStream(File file) throws IORuntimeException {
try {
return new BufferedInputStream(new FileInputStream(file));
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
/**
* 获得输入流
*
* @param path 文件路径
* @return 输入流
* @throws IORuntimeException 文件未找到
*/
public static BufferedInputStream getInputStream(String path) throws IORuntimeException {
return getInputStream(file(path));
}
/**
* 获得BOM输入流，用于处理带BOM头的文件
*
* @param file 文件
* @return 输入流
* @throws IORuntimeException 文件未找到
*/
public static BOMInputStream getBOMInputStream(File file) throws IORuntimeException {
try {
return new BOMInputStream(new FileInputStream(file));
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
/**
* 获得一个文件读取器
*
* @param file 文件
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedReader getUtf8Reader(File file) throws IORuntimeException {
return getReader(file, CharsetUtil.CHARSET_UTF_8);
}
/**
* 获得一个文件读取器
*
* @param path 文件路径
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedReader getUtf8Reader(String path) throws IORuntimeException {
return getReader(path, CharsetUtil.CHARSET_UTF_8);
}
/**
* 获得一个文件读取器
*
* @param file 文件
* @param charsetName 字符集
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedReader getReader(File file, String charsetName) throws IORuntimeException {
return IoUtil.getReader(getInputStream(file), charsetName);
}
/**
* 获得一个文件读取器
*
* @param file 文件
* @param charset 字符集
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedReader getReader(File file, Charset charset) throws IORuntimeException {
return IoUtil.getReader(getInputStream(file), charset);
}
/**
* 获得一个文件读取器
*
* @param path 绝对路径
* @param charsetName 字符集
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedReader getReader(String path, String charsetName) throws IORuntimeException {
return getReader(file(path), charsetName);
}
/**
* 获得一个文件读取器
*
* @param path 绝对路径
* @param charset 字符集
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedReader getReader(String path, Charset charset) throws IORuntimeException {
return getReader(file(path), charset);
}
// -------------------------------------------------------------------------------------------- in end
/**
* 读取文件所有数据 集合类型
* @param path 文件路径
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IORuntimeException IO异常
*/
public static > T readLines(String path, String charset, T collection) throws IORuntimeException {
return readLines(file(path), charset, collection);
}
/**
* 从文件中读取每一行数据
*
* @param 集合类型
* @param path 文件路径
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IORuntimeException IO异常
*/
public static > T readLines(String path, Charset charset, T collection) throws IORuntimeException {
return readLines(file(path), charset, collection);
}
/**
* 从文件中读取每一行数据
*
* @param 集合类型
* @param file 文件路径
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IORuntimeException IO异常
*/
public static > T readLines(File file, String charset, T collection) throws IORuntimeException {
return FileReader.create(file, CharsetUtil.charset(charset)).readLines(collection);
}
/**
* 从文件中读取每一行数据
*
* @param 集合类型
* @param file 文件路径
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IORuntimeException IO异常
*/
public static > T readLines(File file, Charset charset, T collection) throws IORuntimeException {
return FileReader.create(file, charset).readLines(collection);
}
/**
* 从文件中读取每一行数据
*
* @param 集合类型
* @param url 文件的URL
* @param charset 字符集
* @param collection 集合
* @return 文件中的每行内容的集合
* @throws IORuntimeException IO异常
*/
public static > T readLines(URL url, String charset, T collection) throws IORuntimeException {
InputStream in = null;
try {
in = url.openStream();
return IoUtil.readLines(in, charset, collection);
} catch (IOException e) {
throw new IORuntimeException(e);
} finally {
IoUtil.close(in);
}
}
/**
* 从文件中读取每一行数据
*
* @param url 文件的URL
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IORuntimeException IO异常
*/
public static List readLines(URL url, String charset) throws IORuntimeException {
return readLines(url, charset, new ArrayList());
}
/**
* 从文件中读取每一行数据
*
* @param path 文件路径
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IORuntimeException IO异常
*/
public static List readLines(String path, String charset) throws IORuntimeException {
return readLines(path, charset, new ArrayList());
}
/**
* 从文件中读取每一行数据
*
* @param file 文件
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IORuntimeException IO异常
*/
public static List readLines(File file, String charset) throws IORuntimeException {
return readLines(file, charset, new ArrayList());
}
/**
* 从文件中读取每一行数据
*
* @param file 文件
* @param charset 字符集
* @return 文件中的每行内容的集合List
* @throws IORuntimeException IO异常
*/
public static List readLines(File file, Charset charset) throws IORuntimeException {
return readLines(file, charset, new ArrayList());
}
/**
* 按行处理文件内容
*
* @param file 文件
* @param charset 编码
* @param lineHandler {@link LineHandler}行处理器
* @throws IORuntimeException IO异常
*/
public static void readLines(File file, Charset charset, LineHandler lineHandler) throws IORuntimeException {
FileReader.create(file, charset).readLines(lineHandler);
}
/**
* 按照给定的readerHandler读取文件中的数据
*
* @param 集合类型
* @param readerHandler Reader处理类
* @param path 文件的绝对路径
* @param charset 字符集
* @return 从文件中load出的数据
* @throws IORuntimeException IO异常
*/
public static T load(ReaderHandler readerHandler, String path, String charset) throws IORuntimeException {
return FileReader.create(file(path), CharsetUtil.charset(charset)).read(readerHandler);
}
// -------------------------------------------------------------------------------------------- out start
/**
* 获得一个输出流对象
*
* @param file 文件
* @return 输出流对象
* @throws IORuntimeException IO异常
*/
public static BufferedOutputStream getOutputStream(File file) throws IORuntimeException {
try {
return new BufferedOutputStream(new FileOutputStream(touch(file)));
} catch (Exception e) {
throw new IORuntimeException(e);
}
}
/**
* 获得一个输出流对象
*
* @param path 输出到的文件路径，绝对路径
* @return 输出流对象
* @throws IORuntimeException IO异常
*/
public static BufferedOutputStream getOutputStream(String path) throws IORuntimeException {
return getOutputStream(touch(path));
}
/**
* 获得一个带缓存的写入对象
*
* @param path 输出路径，绝对路径
* @param charsetName 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedWriter getWriter(String path, String charsetName, boolean isAppend) throws IORuntimeException {
return getWriter(touch(path), Charset.forName(charsetName), isAppend);
}
/**
* 获得一个带缓存的写入对象
*
* @param path 输出路径，绝对路径
* @param charset 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedWriter getWriter(String path, Charset charset, boolean isAppend) throws IORuntimeException {
return getWriter(touch(path), charset, isAppend);
}
/**
* 获得一个带缓存的写入对象
*
* @param file 输出文件
* @param charsetName 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedWriter getWriter(File file, String charsetName, boolean isAppend) throws IORuntimeException {
return getWriter(file, Charset.forName(charsetName), isAppend);
}
/**
* 获得一个带缓存的写入对象
*
* @param file 输出文件
* @param charset 字符集
* @param isAppend 是否追加
* @return BufferedReader对象
* @throws IORuntimeException IO异常
*/
public static BufferedWriter getWriter(File file, Charset charset, boolean isAppend) throws IORuntimeException {
return FileWriter.create(file, charset).getWriter(isAppend);
}
/**
* 获得一个打印写入对象，可以有print
*
* @param path 输出路径，绝对路径
* @param charset 字符集
* @param isAppend 是否追加
* @return 打印对象
* @throws IORuntimeException IO异常
*/
public static PrintWriter getPrintWriter(String path, String charset, boolean isAppend) throws IORuntimeException {
return new PrintWriter(getWriter(path, charset, isAppend));
}
/**
* 获得一个打印写入对象，可以有print
*
* @param file 文件
* @param charset 字符集
* @param isAppend 是否追加
* @return 打印对象
* @throws IORuntimeException IO异常
*/
public static PrintWriter getPrintWriter(File file, String charset, boolean isAppend) throws IORuntimeException {
return new PrintWriter(getWriter(file, charset, isAppend));
}
// -------------------------------------------------------------------------------------------- out end
/**
* 将String写入文件，覆盖模式，字符集为UTF-8
*
* @param content 写入的内容
* @param path 文件路径
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File writeUtf8String(String content, String path) throws IORuntimeException {
return writeString(content, path, CharsetUtil.CHARSET_UTF_8);
}
/**
* 将String写入文件，覆盖模式，字符集为UTF-8
*
* @param content 写入的内容
* @param file 文件
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File writeUtf8String(String content, File file) throws IORuntimeException {
return writeString(content, file, CharsetUtil.CHARSET_UTF_8);
}
/**
* 将String写入文件，覆盖模式
*
* @param content 写入的内容
* @param path 文件路径
* @param charset 字符集
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File writeString(String content, String path, String charset) throws IORuntimeException {
return writeString(content, touch(path), charset);
}
/**
* 将String写入文件，覆盖模式
*
* @param content 写入的内容
* @param path 文件路径
* @param charset 字符集
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File writeString(String content, String path, Charset charset) throws IORuntimeException {
return writeString(content, touch(path), charset);
}
/**
* 将String写入文件，覆盖模式
*
*
* @param content 写入的内容
* @param file 文件
* @param charset 字符集
* @return 被写入的文件
* @throws IORuntimeException IO异常
*/
public static File writeString(String content, File file, String charset) throws IORuntimeException {
return FileWriter.create(file, CharsetUtil.charset(charset)).write(content);
}
/**
* 将String写入文件，覆盖模式
*
*
* @param content 写入的内容
* @param file 文件
* @param charset 字符集
* @return 被写入的文件
* @throws IORuntimeException IO异常
*/
public static File writeString(String content, File file, Charset charset) throws IORuntimeException {
return FileWriter.create(file, charset).write(content);
}
/**
* 将String写入文件，追加模式
*
* @param content 写入的内容
* @param path 文件路径
* @param charset 字符集
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File appendString(String content, String path, String charset) throws IORuntimeException {
return appendString(content, touch(path), charset);
}
/**
* 将String写入文件，追加模式
*
* @param content 写入的内容
* @param path 文件路径
* @param charset 字符集
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File appendString(String content, String path, Charset charset) throws IORuntimeException {
return appendString(content, touch(path), charset);
}
/**
* 将String写入文件，追加模式
*
* @param content 写入的内容
* @param file 文件
* @param charset 字符集
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File appendString(String content, File file, String charset) throws IORuntimeException {
return FileWriter.create(file, CharsetUtil.charset(charset)).append(content);
}
/**
* 将String写入文件，追加模式
*
* @param content 写入的内容
* @param file 文件
* @param charset 字符集
* @return 写入的文件
* @throws IORuntimeException IO异常
*/
public static File appendString(String content, File file, Charset charset) throws IORuntimeException {
return FileWriter.create(file, charset).append(content);
}
/**
* 将列表写入文件，覆盖模式
*
* @param 集合元素类型
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @throws IORuntimeException IO异常
*/
public static void writeLines(Collection list, String path, String charset) throws IORuntimeException {
writeLines(list, path, charset, false);
}
/**
* 将列表写入文件，覆盖模式
*
* @param 集合元素类型
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @throws IORuntimeException IO异常
*/
public static void writeLines(Collection list, String path, Charset charset) throws IORuntimeException {
writeLines(list, path, charset, false);
}
/**
* 将列表写入文件，追加模式
*
* @param 集合元素类型
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @throws IORuntimeException IO异常
*/
public static void appendLines(Collection list, String path, String charset) throws IORuntimeException {
writeLines(list, path, charset, true);
}
/**
* 将列表写入文件，追加模式
*
* @param 集合元素类型
* @param list 列表
* @param path 绝对路径
* @param charset 字符集
* @throws IORuntimeException IO异常
*/
public static void appendLines(Collection list, String path, Charset charset) throws IORuntimeException {
writeLines(list, path, charset, true);
}
/**
* 将列表写入文件
*
* @param 集合元素类型
* @param list 列表
* @param path 文件路径
* @param charset 字符集
* @param isAppend 是否追加
* @return 文件
* @throws IORuntimeException IO异常
*/
public static File writeLines(Collection list, String path, String charset, boolean isAppend) throws IORuntimeException {
return writeLines(list, file(path), charset, isAppend);
}
/**
* 将列表写入文件
*
* @param 集合元素类型
* @param list 列表
* @param path 文件路径
* @param charset 字符集
* @param isAppend 是否追加
* @return 文件
* @throws IORuntimeException IO异常
*/
public static File writeLines(Collection list, String path, Charset charset, boolean isAppend) throws IORuntimeException {
return writeLines(list, file(path), charset, isAppend);
}
/**
* 将列表写入文件
*
* @param 集合元素类型
* @param list 列表
* @param file 文件
* @param charset 字符集
* @param isAppend 是否追加
* @return 文件
* @throws IORuntimeException IO异常
*/
public static File writeLines(Collection list, File file, String charset, boolean isAppend) throws IORuntimeException {
return FileWriter.create(file, CharsetUtil.charset(charset)).writeLines(list, isAppend);
}
/**
* 将列表写入文件
*
* @param 集合元素类型
* @param list 列表
* @param file 文件
* @param charset 字符集
* @param isAppend 是否追加
* @return 文件
* @throws IORuntimeException IO异常
*/
public static File writeLines(Collection list, File file, Charset charset, boolean isAppend) throws IORuntimeException {
return FileWriter.create(file, charset).writeLines(list, isAppend);
}
/**
* 写数据到文件中
*
* @param data 数据
* @param path 目标文件
* @return 文件
* @throws IORuntimeException IO异常
*/
public static File writeBytes(byte[] data, String path) throws IORuntimeException {
return writeBytes(data, touch(path));
}
/**
* 写数据到文件中
*
* @param dest 目标文件
* @param data 数据
* @return dest
* @throws IORuntimeException IO异常
*/
public static File writeBytes(byte[] data, File dest) throws IORuntimeException {
return writeBytes(data, dest, 0, data.length, false);
}
/**
* 写入数据到文件
*
* @param data 数据
* @param dest 目标文件
* @param off 数据开始位置
* @param len 数据长度
* @param isAppend 是否追加模式
* @return File
* @throws IORuntimeException IO异常
*/
public static File writeBytes(byte[] data, File dest, int off, int len, boolean isAppend) throws IORuntimeException {
return FileWriter.create(dest).write(data, off, len, isAppend);
}
/**
* 将流的内容写入文件 lines = readLines(file, charset);
return FileWriter.create(file, charset).writeLines(lines, lineSeparator, false);
}
}
