Recientemente, para modificar los nombres de archivo de una gran cantidad de dramas estadounidenses favoritos, escribí un widget usando Swing. El código es la parte de procesamiento de archivos. El contenido específico es el siguiente
paquete 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.inputreamreader; importar; 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 java.util.logging.logger; /** * * * @author s.watson */public class filetools {public filetools () {}/** * Formatpath de escape Directorio de archivos * * @param ruta * @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 ()]); matriz de devolución; } / ** * CP Copiar archivo * * @Param Source * @param Destination * @param loop * @return * / public static list <Schil> CP (String Source, String Destination, Boolean Loop) {list <File> list = new ArrayList (); intente {archivo srcfile = nuevo archivo (fuente); Archivo desfile = nuevo archivo (destino); list.addall (cp (srcfile, desfile, bucle)); } capt (excepción ex) {j2log (nulo, nulo, ex); } Lista de retorno; } / ** * CP Copiar archivo * * @Param Source * @param Destination * @param loop * @return * / public static list <Sche> cp (FUNDE FUNDE, File Destination, Boolean Loop) {list <File> list = new ArrayList (); Pruebe {if (! Source.Exists () || Source.ISDirectory ()) {tire nuevo filenotfoundException (); } list.add (cp (fuente, destino)); if (loop) {string [] subfile = source.list (); for (string subpath: subFile) {String src = combinepath (fuente.getPath (), subpath); // La ruta de archivo original del subfile String des = combinepath (destino.getPath (), subpath); // La ruta de destino del archivo subfile subfile subfile = nuevo archivo (src); if (subfile.isfile ()) {list.add (cp (src, des)); } else if (subfile.isDirectory () && loop) {list.addall (cp (src, des, bucle)); }}}}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); } Lista de retorno; } / ** * CP Single File Copiar archivo * * @param Fuente * @param Destination * @return * / public static File Cp (String Source, String Destination) {archivo desfile = null; intente {archivo srcfile = nuevo archivo (fuente); desfile = nuevo archivo (destino); desfile = cp (srcfile, desfile); } capt (excepción ex) {j2log (nulo, nulo, ex); } return desfile; } / ** * CP Single File Copiar archivo * * @param Fuente * @param Destination * @return * / public static File cp (File Foured, File Destination) {FileInputStream in = null; FileOutputStream out = null; Filechannel inc = null; FileChannel outc = null; Pruebe {if (! Source.Exists () || Source.ISDirectory ()) {tire nuevo filenotfoundException (); } if (fuente.getPath (). Equals (Destination.getPath ())) {return Source; } long Allbytes = du (fuente, falso); if (! Destino.Exists ()) {Destination.CreateNewFile (); } in = new FileInputStream (fuente.getPath ()); out = new FileOutputStream (destino); inc = in.getChannel (); outc = out.getChannel (); Bytebuffer bytebuffer = null; larga longitud = 2097152; // tamaño básico, predeterminado 2m largo _2m = 2097152; while (Inc.Position () <inc.size ()) {if (AllBytes> (64 * longitud)) {// Si el tamaño del archivo es mayor de 128 m, el caché se cambia a 64m longitud = 32 * _2m; } else if (Allbytes> (32 * longitud)) {// Si el tamaño del archivo es mayor que 64m, el caché se cambia a 32m longitud = 16 * _2m; } else if (Allbytes> (16 * longitud)) {// Si el tamaño del archivo es mayor que 32m, el caché se cambia a 16m longitud = 8 * _2m; } else if (Allbytes> (8 * longitud)) {// Si el tamaño del archivo es mayor que 16m, el caché se cambia a 8m longitud = 4 * _2m; } else if (Allbytes> (4 * longitud)) {// Si el tamaño del archivo es mayor que 8m, el caché se cambia a 4m longitud = 2 * _2m; } else if (Allbytes> (2 * longitud)) {// Si el tamaño del archivo es mayor que 4m, el caché se cambia a 2M longitud = _2m; } else if (Allbytes> (longitud)) {// Si el tamaño del archivo es mayor que 2m, el caché se cambia a 1M longitud = _2m/2; } else if (Allbytes <longitud) {// Si el archivo es más pequeño que el tamaño base, longitud de salida directamente = Allbytes; } Allbytes = Inc.Size () - Inc.Position (); bytebuffer = bytebuffer.allocatedIrect ((int) longitud); Inc.Read (ByteBuffer); bytebuffer.flip (); OUTC.Write (ByteBuffer); ourc.force (falso); }} capt (excepción ex) {j2log (nulo, nulo, ex); } Finalmente {try {if (null! = inc) {inc.close (); } if (null! = outc) {outc.close (); } if (null! = in) {in.close (); } if (null! = out) {out.close (); }} capt (excepción ex) {j2log (nulo, nulo, ex); }} Destino de retorno; } / ** * Rename el archivo Rename * * @param filepath * @param desde * @param a * @return * / public static file Rename (String filePath, string from, string to) {file newFile = null; intente {archivo OldFile = new File (CombainPath (FilePath, From)); newfile = nuevo archivo (CombainPath (FilePath, To)); renombrar (Newfile, OldFile); } capt (excepción ex) {j2log (nulo, nulo, ex); } return Newfile; } / ** * Rename el archivo Rename * * @param a * @param desde * @return * / public static File Rename (archivo, archivo a) {try {String newpath = a.getPath (); Cadena OldPath = from.getPath (); if (! OldPath.equals (newPath)) {if (! to.exists ()) {from.renameto (a); }}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); } volver a; } / ** * mv mude archivo * * @param nombre de archivo * @param fuente * @param destino * @param cover * / public static void mv (string filename, string shuted, string Destination, Cover) {try {if (! Source.equals (Destination)) {archivo OldFile = new File (CombainPath (fuente, FileName)); Archivo newfile = nuevo archivo (CombainPath (destino, nombre de archivo)); MV (Oldfile, Newfile, Cover); }} capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * mv mude archivo * * @param fuente * @param Destination * @param Cover * / public static void MV (String Source, String Destination, Boolean Cover) {try {if (! Source.equals (Destination)) {archivo OldFile = nuevo archivo (fuente); Archivo newfile = nuevo archivo (destino); MV (Oldfile, Newfile, Cover); }} capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * mv mude archivo * * @param fuente * @param destino * @param portada * / public static void mv (fuente de archivo, destino de archivo, portada booleana) {try {if (! Source.exists ()) {tire nuevo fileNotFoundException (); } StringBuilder filename = new StringBuilder (fuente.getName ()); if (? } else {FileName.append ("_ Copy"); } cp (fuente, nuevo archivo (combainpath (fuente.getParent (), filename.toString ()))); } else {Source.Renameto (destino); }} capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Extensiones Obtenga información de extensión de archivo * * @param filepath * @param filename * @return * / private static string [] extensions (string filepath, string filename) {string [] extension = {}; intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); extensiones (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); } extensión de retorno; } / ** * Extensiones Obtenga información de extensión de archivo * * @param fullpath * @return * / private static string [] extensions (string fullPath) {string [] extension = {}; intente {archivo archivo = nuevo archivo (fullPath); extensiones (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); } extensión de retorno; } / ** * Extensiones Obtenga información de extensión de archivo * * @param archivo * @return * / private static string [] extensions (archivo archivo) {string [] extension = {}; intente {if (file.isfile ()) {string filename = file.getName (); if (filename.lastIndexof (".")> = 0) {int LastIndex = FileName.lastIndexOf ("."); extensión [0] = String.ValueOf (LastIndex); // índice de "." extensión [1] = FileName.Substring (LastIndex + 1); // Extensión Extensión [2] = FileName.Substring (0, LastIndex); // Nombre de archivo}}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); } extensión de retorno; } / ** * ls atravesando el archivo * * @param filepath * @param loop * @return * / public static list <Schil> ls (String filePath, boolean loop) {list <chile> list = new ArrayList (); intente {archivo archivo = nuevo archivo (filepath); list.addall (ls (archivo, bucle)); } capt (excepción ex) {j2log (nulo, nulo, ex); } Lista de retorno; } / ** * ls atravesando el archivo * * @param archivo * @param bucle * @return * / public static list <Sche> ls (archivo archivo, boolean bucle) {list <chile> list = new ArrayList (); intente {list.add (archivo); if (! file.isDirectory ()) {list.add (archivo); } else if (file.isDirectory ()) {file [] sublist = file.listfiles (); sublist = FilesSort (sublista, verdadero); for (archivo subfile: sublist) {if (subfile.isDirectory () && loop) {list.addall (ls (subfile.getpath (), bucle)); } else {list.add (subfile); }}}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); } Lista de retorno; } / ** * FileSort File Ordle (orden ascendente predeterminado) * * @param parentPath * @param sublist * @return * / private static file [] fileSort (file [] infiles, boolean asc) {list <tring> files = new ArrayList (); List <String> dirs = new ArrayList (); for (archivo 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 (archivos); Arrays.sort (Filearray); if (! asc) {arrays.sort (filearray, collections.reverseorder ()); }} String [] dinarray = {}; if (dirs.size ()> 0) {dirarray = list2Array (dirs); Arrays.sort (dirarray); if (! asc) {arrays.sort (dirarray, collections.reverseorder ()); }} return concat2FileArray (Filearray, DirArray); } / ** * Concat2FilearRay Merge Archiver * * @param Old1 * @param Old2 * @return * / private static file [] concat2FileArray (string [] Old1, String [] Old2) {archivo [] newArray = nuevo archivo [old1.length + old2.length]; para (int i = 0, n = old1.length; i <n; i ++) {newArray [i] = nuevo archivo (old1 [i]); } para (int i = 0, j = old1.length, n = (old1.length+old2.length); j <n; i ++, j ++) {newArray [j] = nuevo archivo (old2 [i]); } return NewArray; } / ** * Leer Read File de texto * * @param filepath * @param filename * @param charset * @return * / public static stringBuilder read (string filepath, string filename, string charset) {stringBuilder sb = new StringBuilder (); intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); sb.append (filetools.tail (archivo, falso, 0, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Read Read Archivo de texto * * @param fullpath * @param charset * @return * / public static StringBuilder Read (String FullPath, String Charset) {StringBuilder sb = new StringBuilder (); intente {archivo archivo = nuevo archivo (fullPath); sb.append (filetools.tail (archivo, falso, 0, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Read Read File de texto * * @param Archivo * @param Charset * @return * / public static StringBuilder Read (archivo de archivo, String Charset) {StringBuilder sb = new StringBuilder (); intente {sb.append (filetools.tail (archivo, falso, 0, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Buscar Lea la línea especificada del archivo de texto * * @param filepath * @param filename * @param line * @param charset * @return * / public static stringBuilder finde (string filepath, string filename, int line, string charset) {stringBuilder sb = new StringBuilder (); intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); sb.append (filetools.tail (archivo, true, línea, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Buscar Lea la línea especificada del archivo de texto * * @param fullpath * @param line * @param charset * @return * / public static stringBuilder find (string fullpath, int line, string charset) {stringBuilder sb = new StringBuilder (); intente {archivo archivo = nuevo archivo (fullPath); sb.append (filetools.tail (archivo, true, línea, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Buscar lee la línea especificada del archivo de texto * * @param archivo * @param line * @param Charset * @return * / public static stringBuilder find (archivo archivo, int line, string charset) {stringBuilder sb = new StringBuilder (); intente {sb.append (filetools.tail (archivo, true, línea, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Tail Lea el archivo de texto * * @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 (); intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); sb.append (filetools.tail (archivo, búsqueda, línea, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Tail Read File de texto * * @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 (); intente {archivo archivo = nuevo archivo (fullPath); sb.append (filetools.tail (archivo, búsqueda, línea, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } return sb; } / ** * Tail Read File de texto * * @param archivo * @param charset * @param find * @param line * @return * / public static StringBuilder Tail (archivo de archivo, 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 ()) {tire nuevo filenotfoundException (); } String fullPath = file.getPath (); bufferReader = new BufferedReader (new InputStreamReader (new FileInputStream (FullPath), Charset)); Cadena temp; for (int i = 0; (temp = bufferReader.readline ())! = null; i ++) {if (! find || line == i) {sb.append (temp); }}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); } finalmente {if (null! = bufferReader) {try {bufferReader.close (); } catch (ioException ex) {j2log (nulo, null, ex); }}} return sb; } / ** * SED Leer Archivo de texto * * @param filepath * @param filename * @param charset * @return * / public static list <String> sed (string filepath, string fileName, string charset) {list <string> list = new ArrayList (); intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); list.addall (filetools.sed (archivo, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } Lista de retorno; } / ** * SED Read File de texto * * @param fullpath * @param charset * @return * / public static list <String> sed (string fullpath, string charset) {list <string> list = new ArrayList (); intente {archivo archivo = nuevo archivo (fullPath); list.addall (filetools.sed (archivo, charset)); } capt (excepción ex) {j2log (nulo, nulo, ex); } Lista de retorno; } / ** * SED Read File de texto * * @param Archivo * @param Charset * @return * / public static list <String> sed (archivo de archivo, string charset) {list <string> list = new ArrayList (); BufferedReader BufferReader = NULL; if (null == charset || "" .equals (charset)) {charset = "utf-8"; } try {if (! file.exists () || file.isDirectory ()) {tire nuevo filenotfoundException (); } String fullPath = file.getPath (); bufferReader = new BufferedReader (new InputStreamReader (new FileInputStream (FullPath), Charset)); Cadena temp; for (int i = 0; (temp = bufferReader.readline ())! = null; i ++) {list.add (temp); }} capt (excepción ex) {j2log (nulo, nulo, ex); } finalmente {if (null! = bufferReader) {try {bufferReader.close (); } catch (ioException ex) {j2log (nulo, null, ex); }}} Lista de retorno; } / ** * Cat Read File de texto * * @param filepath * @param filename * @return * / public static byte [] cat (string filepath, string filename) {byte [] output = {}; intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); salida = filetools.cat (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); } salida de retorno; } / ** * Cat leí el archivo de texto * * @param fullpath * @return * / public static byte [] cat (string fullPath) {byte [] output = {}; intente {archivo archivo = nuevo archivo (fullPath); salida = filetools.cat (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); } salida de retorno; } / ** * Cat Read File de texto * * @param archivo * @return * / public static byte [] cat (archivo archivo) {inputStream in = null; byte [] output = {}; Pruebe {if (! file.exists () || file.isDirectory ()) {tire nuevo filenotFoundException (); } String fullPath = file.getPath (); larga longitud = du (archivo, falso); largo _2m = 2097152; byte [] bytes = new byte [(int) longitud]; in = new FileInputStream (FullPath); for (int count = 0; count! = -1;) {if (longitud> 16 * _2m) {longitud = 4 * _2m; } else if (longitud> 8 * _2m) {longitud = 2 * _2m; } else if (longitud> 4 * _2m) {longitud = _2m; } else if (longitud> 2 * _2m) {longitud = _2m / 2; } else if (longitud> _2m) {longitud = _2m / 4; } else {longitud = 4096; } bytes = new byte [(int) longitud]; count = in.read (bytes); output = concataRray (bytes, salida); longitud = in.available (); }} capt (excepción ex) {j2log (nulo, nulo, ex); } finalmente {if (null! = in) {try {in.close (); } capt (excepción ex) {j2log (nulo, nulo, ex); }}} salida de retorno; } / ** * Array de fusión * * @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); devolver NewArray; } / ** * DD Escribir el archivo 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); Archivo archivo = nuevo archivo (fullPath); Filetools.dd (archivo, contenido, isAppend); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * DD Escribe el contenido de contenido de FullPath * * * @param fullpath * @param content * @param isappend * / public static void dd (string fullpath, byte [] content, boolean isappend) {intent {archivo archivo = nuevo archivo (fullPath); Filetools.dd (archivo, contenido, isAppend); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * DD Escribir el archivo FullPath Content Content * * @param File * @param Content * @param isAppend * / public static void dd (archivo archivo, byte [] content, boolean isappend) {fileOutputStream FileOutputStream = null; intente {if (! file.exists ()) {file.createenewfile (); } fileOutputStream = new FileOutputStream (archivo, isAppend); fileOutputStream.Write (contenido); } capt (excepción ex) {j2log (nulo, nulo, ex); } Finalmente {try {if (null! = FileOutputStream) {fileOutputStream.close (); }} catch (ioException ex) {j2log (nulo, null, ex); }}}} / ** * Escribir contenido de archivo de escritura para archivar FullPath * * @param filepath * @param nombre de archivo * @param content * / public static void write (string filepath, string fileName, content con contenido) {try {String fullPath = combinepath (filepath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); Filetools.write (archivo, contenido, verdadero); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Escribir contenido de archivo de escritura para archivar FullPath * * @param fullPath * @param content * / public static void write (string fullPath, string content) {try {file file = new File (fullPath); Filetools.write (archivo, contenido, verdadero); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Escribir contenido de archivo de escritura para archivar FullPath * * @param archivo * @param content * / public static void write (archivo de archivo, contenido de cadena) {try {filetools.write (archivo, content, true); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Write Write (Append) File Content para archivar 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); Archivo archivo = nuevo archivo (fullPath); Filetools.write (archivo, contenido, isAppend); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * escribir contenido de archivo (append) para archivar fullPath * * @param fullpath * @param content * @param isappend * / public static void write (string fullpath, contenido de cadena, isappend) {intente {archivo archivo = nuevo archivo (fullPath); Filetools.write (archivo, contenido, isAppend); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Write Write (Append) File Content para archivar FullPath * * @param archivo * @param content * @param isappend * / public static void write (archivo de archivo, string content, boolean isappend) {filewriter filewriter = null; intente {if (! file.exists ()) {file.createenewfile (); } filewriter = new FileWriter (file.getPath (), isAppend); FileWriter.Write (contenido); } capt (excepción ex) {j2log (nulo, nulo, ex); } finalmente {if (null! = filewriter) {try {filewriter.close (); } catch (ioException ex) {j2log (nulo, null, ex); }}}}} / ** * Tail Agregue contenido de contenido del archivo a la ubicación del índice del archivo * * @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); Archivo archivo = nuevo archivo (fullPath); Filetools.tail (archivo, contenido, índice); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Tail Agregue contenido de contenido de archivo a la ubicación del índice del archivo * * @param fullpath * @param content * @param index * / public static void tail (string fullpath, string content, long index) {try {archivo file = nuevo archivo (fullpath); Filetools.tail (archivo, contenido, índice); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Tail Agregue contenido de contenido de archivo a la ubicación del índice del archivo * * @param archivo * @param contenido * @param index * / public static void tail (archivo de archivo, contenido de cadena, índice largo) {randomAccessFile randomAssFile = null; intente {if (! file.exists ()) {file.createenewfile (); } randomAccessFile = new RandomAccessFile (file.getPath (), "rw"); RandomAccessFile.seek (índice); RandomAccessFile.writytes (contenido); } capt (excepción ex) {j2log (nulo, nulo, ex); } Finalmente {if (null! = randomAccessFile) {try {randomAccessFile.close (); } capt (excepción ex) {j2log (nulo, nulo, ex); }}}}} / ** * mkdir create directorio * * @param filepath * @param filename * @return * / public static file mkdir (string filepath, string filename) {file file = null; intente {string fullPath = combinepath (filePath, nombre de archivo); file = nuevo archivo (plullPath); archivo = mkdir (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); } archivo de retorno; } / ** * Mkdir Crear directorio * * @param fullpath * @return * / public static file mkdir (string fullPath) {file file = null; intente {archivo = nuevo archivo (fullPath); archivo = mkdir (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); } archivo de retorno; }/** * mkdir create directorio * * @param archivo * @return */public static file mkdir (archivo archivo) {try {if (! file.exists ()) {file.mkdir (); // crea si la carpeta no existe}} capt (excepción ex) {j2Log (null, null, ex); } archivo de retorno; } / ** * Touch Crear archivo * * @param filepath * @param filename * / public static void touch (string filepath, string filename) {try {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); touch (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * Touch Crear archivo * * @param fullpath * / public static void touch (string fullPath) {try {archivo file = nuevo archivo (fullPath); touch (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); }}/** * touch create archivo * * @param archivo */public static void touch (archivo de archivo) {try {if (! file.exists ()) {file.createnewfile (); // crea si el archivo no existe}} catch (excepción ex) {j2log (null, null, ex); }} / ** * rm Elimine el archivo * * @param filepath * @param filename * / public static void rm (string filepath, string fileName) {try {string fullPath = combinePath (filePath, fileName); Archivo archivo = nuevo archivo (fullPath); rm (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * rm Eliminar archivo * * @param fullPath * / public static void rm (string fullPath) {try {archivo archivo = nuevo archivo (fullPath); rm (archivo); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * RM Eliminar archivo * * @param archivo * / public static void rm (archivo de archivo) {try {if (! file.exists ()) {tire new FileNotFoundException (); } if (file.isfile ()) {file.delete (); }} capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * rmdir Eliminar directorio * * @param filepath * @param filename * @param loop * / public static void rmdir (string filepath, string fileName, boolean loop) {try {String fullPath = combinepath (filePath, nombre de archivo); Archivo dir = nuevo archivo (FullPath); rmdir (dir, bucle); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * rmdir Eliminar directorio * * @param fullpath * @param loop * / public static void rmdir (string fullpath, boolean loop) {try {file dir = new File (fullPath); rmdir (dir, bucle); } capt (excepción ex) {j2log (nulo, nulo, ex); }} / ** * rmdir Eliminar directorio * * @param dir * @param bucle * / public static void rmdir (archivo dir, boolean loop) {try {if (! dir.exists ()) {tire nuevo fileNotFoundException (); } if (dir.isDirectory ()) {file [] files = dir.listFiles (); int longitud = files.length; for (int i = 0; i <longitud && loop; i ++) {if (files [i] .isDirectory ()) {rmdir (archivos [i], bucle); } else {rm (archivos [i]); }} if (bucle || longitud == 0) {dir.delete (); }}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); }} / ** * du Obtenga el tamaño real del archivo * * @param filepath * @param nombre de archivo * @param bucle * @return * / public static du (string filepath, string filename, boolean loop) {larga tamaño = 0; intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); size = du (archivo, bucle); } capt (excepción ex) {j2log (nulo, nulo, ex); } tamaño de retorno; } / ** * du Obtenga el tamaño real del archivo * * @param filepath * @param filename * @return * / public static du (string filepath, string fileName) {larga tamaño = 0; intente {string fullPath = combinepath (filePath, nombre de archivo); Archivo archivo = nuevo archivo (fullPath); size = du (archivo, falso); } capt (excepción ex) {j2log (nulo, nulo, ex); } tamaño de retorno; } / ** * du Obtenga el tamaño real del archivo * * @param fullpath * @return * / public static long du (string fullPath) {larga tamaño = 0; intente {archivo archivo = nuevo archivo (fullPath); size = du (archivo, falso); } capt (excepción ex) {j2log (nulo, nulo, ex); } tamaño de retorno; } / ** * du Obtenga el tamaño real del archivo * * @param archivo * @return * / public static long du (archivo de archivo) {larga tamaño = 0; intente {size = du (archivo, falso); } capt (excepción ex) {j2log (nulo, nulo, ex); } tamaño de retorno; } / ** * du Obtenga el tamaño real del archivo * * @param fullpath * @param loop * @return * / public static long du (string fullpath, boolean loop) {larga tamaño = 0; intente {archivo archivo = nuevo archivo (fullPath); size = du (archivo, bucle); } capt (excepción ex) {j2log (nulo, nulo, ex); } tamaño de retorno; } / ** * du Obtenga el tamaño real del archivo * * @param archivo * @param loop * @return * / public static du (archivo archivo, boolean loop) {filechannel filechannel = null; tamaño largo = 0; Pruebe {if (! File.Exists ()) {tire nuevo FileNotFoundException (); } if (file.isfile ()) {fileInputStream fis = new FileInputStream (archivo); fileChannel = fis.getChannel (); size = fileChannel.size (); } else if (file.isDirectory ()) {file [] files = file.listfiles (); int longitud = files.length; for (int i = 0; i <longitud && loop; i ++) {if (files [i] .isDirectory ()) {du (files [i], bucle); } else {size += du (archivos [i], falso); }}}} Catch (Exception Ex) {J2Log (NULL, NULL, EX); } finalmente {if (null! = filechannel) {try {filechannel.close (); } capt (excepción ex) {j2log (nulo, nulo, ex); }}} tamaño de retorno; }}Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.