Recently, in order to modify the file names of a large number of favorite American dramas, I wrote a widget using swing. The code is the file processing part. The specific content is as follows
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.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 escape file directory* * @param path * @return */ public static String formatPath(String path) { return path.replaceAll("////", "/"); } /** * combinePath file path merge* * @param eins * @param zwei * @return */ private static String combinePath(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 List conversion array* * @param list * @return */ private static String[] list2Array(List list) { String array[] = (String[]) list.toArray(new String[list.size()]); return array; } /** * cp Copy file* * @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 Copy file* * @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 = combinePath(source.getPath(), subPath);//The original file path of the subfile String des = combinePath(destination.getPath(), subPath);//The target path of the subfile 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 Single file copy file* * @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 Single file copy file* * @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;//Basic size, default 2M long _2M = 2097152; while (inc.position() < inc.size()) { if (allbytes > (64 * length)) {//If the file size is greater than 128M, the cache is changed to 64M length = 32 * _2M; } else if (allbytes > (32 * length)) {//If the file size is greater than 64M, the cache is changed to 32M length = 16 * _2M; } else if (allbytes > (16 * length)) {//If the file size is greater than 32M, the cache is changed to 16M length = 8 * _2M; } else if (allbytes > (8 * length)) {//If the file size is greater than 16M, the cache is changed to 8M length = 4 * _2M; } else if (allbytes > (4 * length)) {//If the file size is greater than 8M, the cache is changed to 4M length = 2 * _2M; } else if (allbytes > (2 * length)) {//If the file size is greater than 4M, the cache is changed to 2M length = _2M; } else if (allbytes > (length)) {//If the file size is greater than 2M, the cache is changed to 1M length = _2M / 2; } else if (allbytes < length) {//If the file is smaller than the base size, output length directly = 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 file 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 file 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 Move file* * @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 Move file* * @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 Move file* * @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("."), "_copy"); } else { fileName.append("_copy"); } cp(source, new File(combainPath(source.getParent(), fileName.toString()))); } else { source.renameTo(destination); } } catch (Exception ex) { j2log(null, null, ex); } } /** * extensions Get file extension information* * @param filePath * @param fileName * @return */ private static String[] extensions(String filePath, String fileName) { String[] extension = {}; try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); extensions(file); } catch (Exception ex) { j2log(null, null, ex); } return extension; } /** * extensions Get file extension information* * @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 Get file extension information* * @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);//Index of "." extension[1] = fileName.substring(lastIndex + 1);//Extension extension[2] = fileName.substring(0, lastIndex);//File name} } } catch (Exception ex) { j2log(null, null, ex); } return extension; } /** * ls traversing the file* * @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 traversing the file* * @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 File sort (default ascending order) * * @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 Merge file array* * @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 Read text file* * @param filePath * @param fileName * @param charset * @return */ public static StringBuilder read(String filePath, String fileName, String charset) { StringBuilder sb = new StringBuilder(); try { String fullPath = combinePath(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 Read text file* * @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 Read text file* * @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 Read the specified line of the text file* * @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 = combinePath(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 Read the specified line of the text file* * @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 Read the specified line of the text file* * @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 Read the text file* * @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 = combinePath(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 Read text file* * @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 Read text file* * @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 Read text file* * @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 = combinePath(filePath, fileName); File file = new File(fullPath); list.addAll(FileTools.sed(file, charset)); } catch (Exception ex) { j2log(null, null, ex); } return list; } /** * sed read text file* * @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 read text file* * @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 Read text file* * @param filePath * @param fileName * @return */ public static byte[] cat(String filePath, String fileName) { byte[] output = {}; try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); output = FileTools.cat(file); } catch (Exception ex) { j2log(null, null, ex); } return output; } /** * cat Read text file* * @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 Read text file* * @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; } /** * Merge array* * @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 Write file fullPath content content * * @param filePath * @param fileName * @param content * @param isAppend */ public static void dd(String filePath, String fileName, byte[] content, boolean isAppend) { try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); FileTools.dd(file, content, isAppend); } catch (Exception ex) { j2log(null, null, ex); } } /** * dd Write file fullPath content 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 Write file fullPath content 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 Write file content to file fullPath * * @param filePath * @param fileName * @param content */ public static void write(String filePath, String fileName, String content) { try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); FileTools.write(file, content, true); } catch (Exception ex) { j2log(null, null, ex); } } /** * write Write file content to file 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 Write file content to file 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 Write (append) file content to file fullPath * * @param filePath * @param fileName * @param content * @param isAppend */ public static void write(String filePath, String fileName, String content, boolean isAppend) { try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); FileTools.write(file, content, isAppend); } catch (Exception ex) { j2log(null, null, ex); } } /** * write Write (append) file content to file 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 Write (append) file content to file 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 Add file content content to the index location of the file* * @param filePath * @param fileName * @param content * @param index */ public static void tail(String filePath, String fileName, String content, long index) { try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); FileTools.tail(file, content, index); } catch (Exception ex) { j2log(null, null, ex); } } /** * tail Add file content content to the index location of the file* * @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 Add file content content to the index location of the file* * @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 Create directory* * @param filePath * @param fileName * @return */ public static File mkdir(String filePath, String fileName) { File file = null; try { String fullPath = combinePath(filePath, fileName); file = new File(fullPath); file = mkdir(file); } catch (Exception ex) { j2log(null, null, ex); } return file; } /** * mkdir Create directory* * @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 Create directory * * @param file * @return */ public static File mkdir(File file) { try { if (!file.exists()) { file.mkdir();//Create if the folder does not exist} } catch (Exception ex) { j2log(null, null, ex); } return file; } /** * touch Create file* * @param filePath * @param fileName */ public static void touch(String filePath, String fileName) { try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); touch(file); } catch (Exception ex) { j2log(null, null, ex); } } /** * touch Create file* * @param fullPath */ public static void touch(String fullPath) { try { File file = new File(fullPath); touch(file); } catch (Exception ex) { j2log(null, null, ex); } } /** * touch Create file* * @param file */ public static void touch(File file) { try { if (!file.exists()) { file.createNewFile();//Create if the file does not exist} } catch (Exception ex) { j2log(null, null, ex); } } /** * rm Delete the file* * @param filePath * @param fileName */ public static void rm(String filePath, String fileName) { try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); rm(file); } catch (Exception ex) { j2log(null, null, ex); } } /** * rm Delete file* * @param fullPath */ public static void rm(String fullPath) { try { File file = new File(fullPath); rm(file); } catch (Exception ex) { j2log(null, null, ex); } } /** * rm Delete file* * @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 Delete directory* * @param filePath * @param fileName * @param loop */ public static void rmdir(String filePath, String fileName, boolean loop) { try { String fullPath = combinePath(filePath, fileName); File dir = new File(fullPath); rmdir(dir, loop); } catch (Exception ex) { j2log(null, null, ex); } } /** * rmdir Delete directory* * @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 Delete directory* * @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 Get the actual file size* * @param filePath * @param fileName * @param loop * @return */ public static long du(String filePath, String fileName, boolean loop) { long size = 0; try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); size = du(file, loop); } catch (Exception ex) { j2log(null, null, ex); } return size; } /** * du Get the actual file size* * @param filePath * @param fileName * @return */ public static long du(String filePath, String fileName) { long size = 0; try { String fullPath = combinePath(filePath, fileName); File file = new File(fullPath); size = du(file, false); } catch (Exception ex) { j2log(null, null, ex); } return size; } /** * du Get the actual file size* * @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 Get the actual file size* * @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 Get the actual file size* * @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 Get the actual file size* * @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; }}The above is all about this article, I hope it will be helpful to everyone's learning.