java文件操作工具类_java

最近为了修改大量收藏的美剧文件名，用swing写了个小工具，代码是文件处理部分，具体内容如下

package datei.steuern;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author s.watson
 */
public class FileTools {

 public FileTools() {

 }

 /**
 * formatPath 转义文件目录
 *
 * @param path
 * @return
 */
 public static String formatPath(String path) {
 return path.replaceAll("\\\\", "/");
 }

 /**
 * combainPath文件路径合并
 *
 * @param eins
 * @param zwei
 * @return
 */
 private static String combainPath(String eins, String zwei) {
 String dori = "";
 eins = null == eins ? "" : formatPath(eins);
 zwei = null == zwei ? "" : formatPath(zwei);
 if (!eins.endsWith("/") && zwei.indexOf("/") != 0) {
 dori = eins + "/" + zwei;
 } else {
 dori = (eins + zwei).replaceAll("//", "/");
 }
 return dori;
 }

 /**
 * list2Array 列表转换数组
 *
 * @param list
 * @return
 */
 private static String[] list2Array(List list) {
 String array[] = (String[]) list.toArray(new String[list.size()]);
 return array;
 }

 /**
 * cp 复制文件
 *
 * @param source
 * @param destination
 * @param loop
 * @return
 */
 public static List<File> cp(String source, String destination, boolean loop) {
 List<File> list = new ArrayList();
 try {
 File srcFile = new File(source);
 File desFile = new File(destination);
 list.addAll(cp(srcFile, desFile, loop));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return list;
 }

 /**
 * cp 复制文件
 *
 * @param source
 * @param destination
 * @param loop
 * @return
 */
 public static List<File> cp(File source, File destination, boolean loop) {
 List<File> list = new ArrayList();
 try {
 if (!source.exists() || source.isDirectory()) {
 throw new FileNotFoundException();
 }
 list.add(cp(source, destination));
 if (loop) {
 String[] subFile = source.list();
 for (String subPath : subFile) {
  String src = combainPath(source.getPath(), subPath);//子文件原文件路径
  String des = combainPath(destination.getPath(), subPath);//子文件目标路径
  File subfile = new File(src);
  if (subfile.isFile()) {
  list.add(cp(src, des));
  } else if (subfile.isDirectory() && loop) {
  list.addAll(cp(src, des, loop));
  }
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return list;
 }

 /**
 * cp 单文件复制文件
 *
 * @param source
 * @param destination
 * @return
 */
 public static File cp(String source, String destination) {
 File desFile = null;
 try {
 File srcFile = new File(source);
 desFile = new File(destination);
 desFile = cp(srcFile, desFile);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return desFile;
 }

 /**
 * cp 单文件复制文件
 *
 * @param source
 * @param destination
 * @return
 */
 public static File cp(File source, File destination) {
 FileInputStream in = null;
 FileOutputStream out = null;
 FileChannel inc = null;
 FileChannel outc = null;
 try {
 if (!source.exists() || source.isDirectory()) {
 throw new FileNotFoundException();
 }
 if (source.getPath().equals(destination.getPath())) {
 return source;
 }
 long allbytes = du(source, false);
 if (!destination.exists()) {
 destination.createNewFile();
 }
 in = new FileInputStream(source.getPath());
 out = new FileOutputStream(destination);
 inc = in.getChannel();
 outc = out.getChannel();
 ByteBuffer byteBuffer = null;
 long length = 2097152;//基本大小，默认2M
 long _2M = 2097152;
 while (inc.position() < inc.size()) {
 if (allbytes > (64 * length)) {//如果文件大小大于128M 缓存改为64M
  length = 32 * _2M;
 } else if (allbytes > (32 * length)) {//如果文件大小大于64M 缓存改为32M
  length = 16 * _2M;
 } else if (allbytes > (16 * length)) {//如果文件大小大于32M 缓存改为16M
  length = 8 * _2M;
 } else if (allbytes > (8 * length)) {//如果文件大小大于16M 缓存改为8M
  length = 4 * _2M;
 } else if (allbytes > (4 * length)) {//如果文件大小大于8M 缓存改为4M
  length = 2 * _2M;
 } else if (allbytes > (2 * length)) {//如果文件大小大于4M 缓存改为2M
  length = _2M;
 } else if (allbytes > (length)) {//如果文件大小大于2M 缓存改为1M
  length = _2M / 2;
 } else if (allbytes < length) {//如果文件小于基本大小，直接输出
  length = allbytes;
 }
 allbytes = inc.size() - inc.position();
 byteBuffer = ByteBuffer.allocateDirect((int) length);
 inc.read(byteBuffer);
 byteBuffer.flip();
 outc.write(byteBuffer);
 outc.force(false);
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 try {
 if (null != inc) {
  inc.close();
 }
 if (null != outc) {
  outc.close();
 }
 if (null != in) {
  in.close();
 }
 if (null != out) {
  out.close();
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }
 return destination;
 }

 /**
 * rename 文件重命名
 *
 * @param filePath
 * @param from
 * @param to
 * @return
 */
 public static File rename(String filePath, String from, String to) {
 File newFile = null;
 try {
 File oldFile = new File(combainPath(filePath, from));
 newFile = new File(combainPath(filePath, to));
 rename(newFile, oldFile);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return newFile;
 }

 /**
 * rename 文件重命名
 *
 * @param to
 * @param from
 * @return
 */
 public static File rename(File from, File to) {
 try {
 String newPath = to.getPath();
 String oldPath = from.getPath();
 if (!oldPath.equals(newPath)) {
 if (!to.exists()) {
  from.renameTo(to);
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return to;
 }

 /**
 * mv 移动文件
 *
 * @param fileName
 * @param source
 * @param destination
 * @param cover
 */
 public static void mv(String fileName, String source, String destination, boolean cover) {
 try {
 if (!source.equals(destination)) {
 File oldFile = new File(combainPath(source, fileName));
 File newFile = new File(combainPath(destination, fileName));
 mv(oldFile, newFile, cover);
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * mv 移动文件
 *
 * @param source
 * @param destination
 * @param cover
 */
 public static void mv(String source, String destination, boolean cover) {
 try {
 if (!source.equals(destination)) {
 File oldFile = new File(source);
 File newFile = new File(destination);
 mv(oldFile, newFile, cover);
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * mv 移动文件
 *
 * @param source
 * @param destination
 * @param cover
 */
 public static void mv(File source, File destination, boolean cover) {
 try {
 if (!source.exists()) {
 throw new FileNotFoundException();
 }
 StringBuilder fileName = new StringBuilder(source.getName());
 if (!cover && source.getPath().equals(destination.getPath())) {
 if (fileName.indexOf(".") > 0) {
  fileName.insert(fileName.lastIndexOf("."), "_副本");
 } else {
  fileName.append("_副本");
 }
 cp(source, new File(combainPath(source.getParent(), fileName.toString())));
 } else {
 source.renameTo(destination);
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * extensions 获取文件扩展名信息
 *
 * @param filePath
 * @param fileName
 * @return
 */
 private static String[] extensions(String filePath, String fileName) {
 String[] extension = {};
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 extensions(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return extension;
 }

 /**
 * extensions 获取文件扩展名信息
 *
 * @param fullPath
 * @return
 */
 private static String[] extensions(String fullPath) {
 String[] extension = {};
 try {
 File file = new File(fullPath);
 extensions(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return extension;
 }

 /**
 * extensions 获取文件扩展名信息
 *
 * @param file
 * @return
 */
 private static String[] extensions(File file) {
 String[] extension = {};
 try {
 if (file.isFile()) {
 String fileName = file.getName();
 if (fileName.lastIndexOf(".") >= 0) {
  int lastIndex = fileName.lastIndexOf(".");
  extension[0] = String.valueOf(lastIndex);//扩展名的“.”的索引
  extension[1] = fileName.substring(lastIndex + 1);//扩展名
  extension[2] = fileName.substring(0, lastIndex);//文件名
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return extension;
 }

 /**
 * ls 遍历文件
 *
 * @param filePath
 * @param loop
 * @return
 */
 public static List<File> ls(String filePath, boolean loop) {
 List<File> list = new ArrayList();
 try {
 File file = new File(filePath);
 list.addAll(ls(file, loop));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return list;
 }

 /**
 * ls 遍历文件
 *
 * @param file
 * @param loop
 * @return
 */
 public static List<File> ls(File file, boolean loop) {
 List<File> list = new ArrayList();
 try {
 list.add(file);
 if (!file.isDirectory()) {
 list.add(file);
 } else if (file.isDirectory()) {
 File[] subList = file.listFiles();
 subList = filesSort(subList, true);
 for (File subFile : subList) {
  if (subFile.isDirectory() && loop) {
  list.addAll(ls(subFile.getPath(), loop));
  } else {
  list.add(subFile);
  }
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return list;
 }

 /**
 * filesSort 文件排序（默认升序）
 *
 * @param parentPath
 * @param subList
 * @return
 */
 private static File[] filesSort(File[] inFiles, boolean asc) {
 List<String> files = new ArrayList();
 List<String> dirs = new ArrayList();
 for (File subFile : inFiles) {
 if (subFile.isDirectory()) {
 dirs.add(subFile.getPath());
 } else if (subFile.isFile()) {
 files.add(subFile.getPath());
 }
 }
 String[] fileArray = {};
 if (files.size() > 0) {
 fileArray = list2Array(files);
 Arrays.sort(fileArray);
 if (!asc) {
 Arrays.sort(fileArray, Collections.reverseOrder());
 }
 }
 String[] dirArray = {};
 if (dirs.size() > 0) {
 dirArray = list2Array(dirs);
 Arrays.sort(dirArray);
 if (!asc) {
 Arrays.sort(dirArray, Collections.reverseOrder());
 }
 }
 return concat2FileArray(fileArray, dirArray);
 }

 /**
 * concat2FileArray 合并文件数组
 *
 * @param old1
 * @param old2
 * @return
 */
 private static File[] concat2FileArray(String[] old1, String[] old2) {
 File[] newArray = new File[old1.length + old2.length];
 for (int i = 0, n = old1.length; i < n; i++) {
 newArray[i] = new File(old1[i]);
 }
 for (int i = 0, j = old1.length, n = (old1.length + old2.length); j < n; i++, j++) {
 newArray[j] = new File(old2[i]);
 }
 return newArray;
 }

 /**
 * read 读取文本文件
 *
 * @param filePath
 * @param fileName
 * @param charset
 * @return
 */
 public static StringBuilder read(String filePath, String fileName, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 sb.append(FileTools.tail(file, false, 0, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * read 读取文本文件
 *
 * @param fullPath
 * @param charset
 * @return
 */
 public static StringBuilder read(String fullPath, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 File file = new File(fullPath);
 sb.append(FileTools.tail(file, false, 0, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * read 读取文本文件
 *
 * @param file
 * @param charset
 * @return
 */
 public static StringBuilder read(File file, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 sb.append(FileTools.tail(file, false, 0, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * find 读取文本文件指定行
 *
 * @param filePath
 * @param fileName
 * @param line
 * @param charset
 * @return
 */
 public static StringBuilder find(String filePath, String fileName, int line, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 sb.append(FileTools.tail(file, true, line, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * find 读取文本文件指定行
 *
 * @param fullPath
 * @param line
 * @param charset
 * @return
 */
 public static StringBuilder find(String fullPath, int line, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 File file = new File(fullPath);
 sb.append(FileTools.tail(file, true, line, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * find 读取文本文件指定行
 *
 * @param file
 * @param line
 * @param charset
 * @return
 */
 public static StringBuilder find(File file, int line, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 sb.append(FileTools.tail(file, true, line, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * tail 读取文本文件
 *
 * @param filePath
 * @param fileName
 * @param charset
 * @param find
 * @param line
 * @return
 */
 public static StringBuilder tail(String filePath, String fileName, boolean find, int line, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 sb.append(FileTools.tail(file, find, line, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * tail 读取文本文件
 *
 * @param fullPath
 * @param charset
 * @param find
 * @param line
 * @return
 */
 public static StringBuilder tail(String fullPath, boolean find, int line, String charset) {
 StringBuilder sb = new StringBuilder();
 try {
 File file = new File(fullPath);
 sb.append(FileTools.tail(file, find, line, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return sb;
 }

 /**
 * tail 读取文本文件
 *
 * @param file
 * @param charset
 * @param find
 * @param line
 * @return
 */
 public static StringBuilder tail(File file, boolean find, int line, String charset) {
 StringBuilder sb = new StringBuilder();
 BufferedReader bufferReader = null;
 if (null == charset || "".equals(charset)) {
 charset = "UTF-8";
 }
 try {
 if (!file.exists() || file.isDirectory()) {
 throw new FileNotFoundException();
 }
 String fullPath = file.getPath();
 bufferReader = new BufferedReader(new InputStreamReader(new FileInputStream(fullPath), charset));
 String temp;
 for (int i = 0; (temp = bufferReader.readLine()) != null; i++) {
 if (!find || line == i) {
  sb.append(temp);
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 if (null != bufferReader) {
 try {
  bufferReader.close();
 } catch (IOException ex) {
  j2log(null, null, ex);
 }
 }
 }
 return sb;
 }

 /**
 * sed 读取文本文件
 *
 * @param filePath
 * @param fileName
 * @param charset
 * @return
 */
 public static List<String> sed(String filePath, String fileName, String charset) {
 List<String> list = new ArrayList();
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 list.addAll(FileTools.sed(file, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return list;
 }

 /**
 * sed 读取文本文件
 *
 * @param fullPath
 * @param charset
 * @return
 */
 public static List<String> sed(String fullPath, String charset) {
 List<String> list = new ArrayList();
 try {
 File file = new File(fullPath);
 list.addAll(FileTools.sed(file, charset));
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return list;
 }

 /**
 * sed 读取文本文件
 *
 * @param file
 * @param charset
 * @return
 */
 public static List<String> sed(File file, String charset) {
 List<String> list = new ArrayList();
 BufferedReader bufferReader = null;
 if (null == charset || "".equals(charset)) {
 charset = "UTF-8";
 }
 try {
 if (!file.exists() || file.isDirectory()) {
 throw new FileNotFoundException();
 }
 String fullPath = file.getPath();
 bufferReader = new BufferedReader(new InputStreamReader(new FileInputStream(fullPath), charset));
 String temp;
 for (int i = 0; (temp = bufferReader.readLine()) != null; i++) {
 list.add(temp);
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 if (null != bufferReader) {
 try {
  bufferReader.close();
 } catch (IOException ex) {
  j2log(null, null, ex);
 }
 }
 }
 return list;
 }

 /**
 * cat 读取文本文件
 *
 * @param filePath
 * @param fileName
 * @return
 */
 public static byte[] cat(String filePath, String fileName) {
 byte[] output = {};
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 output = FileTools.cat(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return output;
 }

 /**
 * cat 读取文本文件
 *
 * @param fullPath
 * @return
 */
 public static byte[] cat(String fullPath) {
 byte[] output = {};
 try {
 File file = new File(fullPath);
 output = FileTools.cat(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return output;
 }

 /**
 * cat 读取文本文件
 *
 * @param file
 * @return
 */
 public static byte[] cat(File file) {
 InputStream in = null;
 byte[] output = {};
 try {
 if (!file.exists() || file.isDirectory()) {
 throw new FileNotFoundException();
 }
 String fullPath = file.getPath();
 long length = du(file, false);
 long _2M = 2097152;
 byte[] bytes = new byte[(int) length];
 in = new FileInputStream(fullPath);
 for (int count = 0; count != -1;) {
 if (length > 16 * _2M) {
  length = 4 * _2M;
 } else if (length > 8 * _2M) {
  length = 2 * _2M;
 } else if (length > 4 * _2M) {
  length = _2M;
 } else if (length > 2 * _2M) {
  length = _2M / 2;
 } else if (length > _2M) {
  length = _2M / 4;
 } else {
  length = 4096;
 }
 bytes = new byte[(int) length];
 count = in.read(bytes);
 output = concatArray(bytes, output);
 length = in.available();
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 if (null != in) {
 try {
  in.close();
 } catch (Exception ex) {
  j2log(null, null, ex);
 }
 }
 }
 return output;
 }

 /**
 * 合并数组
 *
 * @param old1
 * @param old2
 * @return
 */
 private static byte[] concatArray(byte[] old1, byte[] old2) {
 byte[] newArray = new byte[old1.length + old2.length];
 System.arraycopy(old1, 0, newArray, 0, old1.length);
 System.arraycopy(old2, 0, newArray, old1.length, old2.length);
 return newArray;
 }

 /**
 * dd 写入文件fullPath内容content
 *
 * @param filePath
 * @param fileName
 * @param content
 * @param isAppend
 */
 public static void dd(String filePath, String fileName, byte[] content, boolean isAppend) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 FileTools.dd(file, content, isAppend);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * dd 写入文件fullPath内容content
 *
 * @param fullPath
 * @param content
 * @param isAppend
 */
 public static void dd(String fullPath, byte[] content, boolean isAppend) {
 try {
 File file = new File(fullPath);
 FileTools.dd(file, content, isAppend);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * dd 写入文件fullPath内容content
 *
 * @param file
 * @param content
 * @param isAppend
 */
 public static void dd(File file, byte[] content, boolean isAppend) {
 FileOutputStream fileOutputStream = null;
 try {
 if (!file.exists()) {
 file.createNewFile();
 }
 fileOutputStream = new FileOutputStream(file, isAppend);
 fileOutputStream.write(content);
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 try {
 if (null != fileOutputStream) {
  fileOutputStream.close();
 }
 } catch (IOException ex) {
 j2log(null, null, ex);
 }
 }
 }

 /**
 * write 写文件内容content到文件fullPath
 *
 * @param filePath
 * @param fileName
 * @param content
 */
 public static void write(String filePath, String fileName, String content) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 FileTools.write(file, content, true);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * write 写文件内容content到文件fullPath
 *
 * @param fullPath
 * @param content
 */
 public static void write(String fullPath, String content) {
 try {
 File file = new File(fullPath);
 FileTools.write(file, content, true);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * write 写文件内容content到文件fullPath
 *
 * @param file
 * @param content
 */
 public static void write(File file, String content) {
 try {
 FileTools.write(file, content, true);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * write 写（追加）文件内容content到文件fullPath
 *
 * @param filePath
 * @param fileName
 * @param content
 * @param isAppend
 */
 public static void write(String filePath, String fileName, String content, boolean isAppend) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 FileTools.write(file, content, isAppend);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * write 写（追加）文件内容content到文件fullPath
 *
 * @param fullPath
 * @param content
 * @param isAppend
 */
 public static void write(String fullPath, String content, boolean isAppend) {
 try {
 File file = new File(fullPath);
 FileTools.write(file, content, isAppend);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * write 写（追加）文件内容content到文件fullPath
 *
 * @param file
 * @param content
 * @param isAppend
 */
 public static void write(File file, String content, boolean isAppend) {
 FileWriter fileWriter = null;
 try {
 if (!file.exists()) {
 file.createNewFile();
 }
 fileWriter = new FileWriter(file.getPath(), isAppend);
 fileWriter.write(content);
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 if (null != fileWriter) {
 try {
  fileWriter.close();
 } catch (IOException ex) {
  j2log(null, null, ex);
 }
 }
 }
 }

 /**
 * tail 添加文件内容content到文件的index位置
 *
 * @param filePath
 * @param fileName
 * @param content
 * @param index
 */
 public static void tail(String filePath, String fileName, String content, long index) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 FileTools.tail(file, content, index);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * tail 添加文件内容content到文件的index位置
 *
 * @param fullPath
 * @param content
 * @param index
 */
 public static void tail(String fullPath, String content, long index) {
 try {
 File file = new File(fullPath);
 FileTools.tail(file, content, index);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * tail 添加文件内容content到文件的index位置
 *
 * @param file
 * @param content
 * @param index
 */
 public static void tail(File file, String content, long index) {
 RandomAccessFile randomAccessFile = null;
 try {
 if (!file.exists()) {
 file.createNewFile();
 }
 randomAccessFile = new RandomAccessFile(file.getPath(), "rw");
 randomAccessFile.seek(index);
 randomAccessFile.writeBytes(content);
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 if (null != randomAccessFile) {
 try {
  randomAccessFile.close();
 } catch (Exception ex) {
  j2log(null, null, ex);
 }
 }
 }
 }

 /**
 * mkdir 创建目录
 *
 * @param filePath
 * @param fileName
 * @return
 */
 public static File mkdir(String filePath, String fileName) {
 File file = null;
 try {
 String fullPath = combainPath(filePath, fileName);
 file = new File(fullPath);
 file = mkdir(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return file;
 }

 /**
 * mkdir 创建目录
 *
 * @param fullPath
 * @return
 */
 public static File mkdir(String fullPath) {
 File file = null;
 try {
 file = new File(fullPath);
 file = mkdir(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return file;
 }

 /**
 * mkdir 创建目录
 *
 * @param file
 * @return
 */
 public static File mkdir(File file) {
 try {
 if (!file.exists()) {
 file.mkdir();//如果文件夹不存在则创建
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return file;
 }

 /**
 * touch 创建文件
 *
 * @param filePath
 * @param fileName
 */
 public static void touch(String filePath, String fileName) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 touch(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * touch 创建文件
 *
 * @param fullPath
 */
 public static void touch(String fullPath) {
 try {
 File file = new File(fullPath);
 touch(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * touch 创建文件
 *
 * @param file
 */
 public static void touch(File file) {
 try {
 if (!file.exists()) {
 file.createNewFile();//如果文件不存在则创建
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * rm 删除文件
 *
 * @param filePath
 * @param fileName
 */
 public static void rm(String filePath, String fileName) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 rm(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * rm 删除文件
 *
 * @param fullPath
 */
 public static void rm(String fullPath) {
 try {
 File file = new File(fullPath);
 rm(file);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * rm 删除文件
 *
 * @param file
 */
 public static void rm(File file) {
 try {
 if (!file.exists()) {
 throw new FileNotFoundException();
 }
 if (file.isFile()) {
 file.delete();
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * rmdir 删除目录
 *
 * @param filePath
 * @param fileName
 * @param loop
 */
 public static void rmdir(String filePath, String fileName, boolean loop) {
 try {
 String fullPath = combainPath(filePath, fileName);
 File dir = new File(fullPath);
 rmdir(dir, loop);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * rmdir 删除目录
 *
 * @param fullPath
 * @param loop
 */
 public static void rmdir(String fullPath, boolean loop) {
 try {
 File dir = new File(fullPath);
 rmdir(dir, loop);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * rmdir 删除目录
 *
 * @param dir
 * @param loop
 */
 public static void rmdir(File dir, boolean loop) {
 try {
 if (!dir.exists()) {
 throw new FileNotFoundException();
 }
 if (dir.isDirectory()) {
 File[] files = dir.listFiles();
 int length = files.length;
 for (int i = 0; i < length && loop; i++) {
  if (files[i].isDirectory()) {
  rmdir(files[i], loop);
  } else {
  rm(files[i]);
  }
 }
 if (loop || length == 0) {
  dir.delete();
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 }

 /**
 * du 获取文件实际大小
 *
 * @param filePath
 * @param fileName
 * @param loop
 * @return
 */
 public static long du(String filePath, String fileName, boolean loop) {
 long size = 0;
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 size = du(file, loop);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return size;
 }

 /**
 * du 获取文件实际大小
 *
 * @param filePath
 * @param fileName
 * @return
 */
 public static long du(String filePath, String fileName) {
 long size = 0;
 try {
 String fullPath = combainPath(filePath, fileName);
 File file = new File(fullPath);
 size = du(file, false);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return size;
 }

 /**
 * du 获取文件实际大小
 *
 * @param fullPath
 * @return
 */
 public static long du(String fullPath) {
 long size = 0;
 try {
 File file = new File(fullPath);
 size = du(file, false);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return size;
 }

 /**
 * du 获取文件实际大小
 *
 * @param file
 * @return
 */
 public static long du(File file) {
 long size = 0;
 try {
 size = du(file, false);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return size;
 }

 /**
 * du 获取文件实际大小
 *
 * @param fullPath
 * @param loop
 * @return
 */
 public static long du(String fullPath, boolean loop) {
 long size = 0;
 try {
 File file = new File(fullPath);
 size = du(file, loop);
 } catch (Exception ex) {
 j2log(null, null, ex);
 }
 return size;
 }

 /**
 * du 获取文件实际大小
 *
 * @param file
 * @param loop
 * @return
 */
 public static long du(File file, boolean loop) {
 FileChannel fileChannel = null;
 long size = 0;
 try {
 if (!file.exists()) {
 throw new FileNotFoundException();
 }
 if (file.isFile()) {
 FileInputStream fis = new FileInputStream(file);
 fileChannel = fis.getChannel();
 size = fileChannel.size();
 } else if (file.isDirectory()) {
 File[] files = file.listFiles();
 int length = files.length;
 for (int i = 0; i < length && loop; i++) {
  if (files[i].isDirectory()) {
  du(files[i], loop);
  } else {
  size += du(files[i], false);
  }
 }
 }
 } catch (Exception ex) {
 j2log(null, null, ex);
 } finally {
 if (null != fileChannel) {
 try {
  fileChannel.close();
 } catch (Exception ex) {
  j2log(null, null, ex);
 }
 }
 }
 return size;
 }
}

以上就是本文的全部内容，希望对大家的学习有所帮助。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索java
， 文件操作
工具类
java操作文件的工具类、java操作redis工具类、java 集合操作工具类、java 日期操作工具类、java数据库操作工具类，以便于您获取更多的相关知识。

时间： 2024-11-30 15:32:29

java文件操作工具类_java的相关文章

java文件操作工具类实现复制文件和文件合并_java

两个方法:1.复制一个目录下面的所有文件和文件夹2.将一个文件目录下面的所有文本文件合并到同一个文件中 复制代码 代码如下: package com.firewolf.test; import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException; public class FileReaderUtil { public static void

java日期操作工具类（获取指定日期、日期转换、相隔天数）_java

本文实例为大家分享了java日期操作工具类,获取指定日期前一天.后一天:日期转换:两个日期之间相隔天数等工具类,供大家参考,具体内容如下 import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.List; public class

java文件操作类(非常强大)

 代码如下 复制代码 package org.guess.core.utils;   import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import

深入理解Java 对象和类_java

Java作为一种面向对象语言.支持以下基本概念: •多态 •继承 •封装 •抽象 •类 •对象 •实例 •方法 •消息解析 本节我们重点研究对象和类的概念. •对象:对象是类的一个实例,有状态和行为.例如,一条狗是一个对象,它的状态有:颜色.名字.品种:行为有:摇尾巴.叫.吃等. •类:类是一个模板,它描述一类对象的行为和状态. Java中的对象 现在让我们深入了解什么是对象.看看周围真实的世界,会发现身边有很多对象,车,狗,人等等.所有这些对象都有自己的状态和行为. 拿一条狗来举例,它的状态有

纯Java文件操作工具，支持文件、文件夹的复制、删除、移动

一.认识UUID UUID 维基百科,自由的百科全书 通用唯一识别码 (Universally Unique Identifier, UUID) 是一个软件建构的标准,亦为自由软件基金会 (Open Software Foundation, OSF) 的组织在分布式计算环境 (Distributed Computing Environment, DCE) 领域的一部份. UUID 的目的,是让分布式系统中的所有元素,都能有唯一的辨识信息,而不需要通过中央控制端来做辨识信息的指定.如此一来,每个人

Java Socket编程（二） Java面向连接的类_Java编程

文章来源:aspcn 作者:孙雯 Java面向连接的类 Sockets有两种主要的操作方式:面向连接的和无连接的.面向连接的sockets操作就像一部电话,他们必须建立一个连接和一人呼叫.所有的事情在到达时的顺序与它们出发时的顺序时一样.无连接的sockets操作就像是一个邮件投递,,没有什么保证,多个邮件可能在到达时的顺序与出发时的顺序不一样. 到底用哪种模式是邮应用程序的需要决定的.如果可靠性更重要的话,用面向连接的操作会好一些.比如文件服务器需要他们的数据的正确性和有序性.如果一些数据丢失

详解Java中的File文件类以及FileDescriptor文件描述类_java

File File 是"文件"和"目录路径名"的抽象表示形式. File 直接继承于Object,实现了Serializable接口和Comparable接口.实现Serializable接口,意味着File对象支持序列化操作.而实现Comparable接口,意味着File对象之间可以比较大小:File能直接被存储在有序集合(如TreeSet.TreeMap中).1. 新建目录的常用方法方法1:根据相对路径新建目录. 示例代码如下(在当前路径下新建目录"d

Java图像处理工具类_java

本工具类的功能:缩放图像.切割图像.图像类型转换.彩色转黑白.文字水印.图片水印等 复制代码 代码如下: package net.kitbox.util; import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.Re

Java:IO操作工具类

[1] String fileReaderStringHandle(String fileName) 将文件(由fileName指定)读入到一个字符串: [2] byte[] fileReaderByteHandle(String fileName) 将文件(由fileName指定)读入到一个字节数组: [3] void fileWriterHandle(String fileName, String text) 将字符串(由text指定)写出到一个文件(由fileName指定). IOUtil