La copia del código es la siguiente:
paquete com.xyq.io.simply.core;
import java.io.file;
import java.io.ioException;
import java.nio.file.filevisitresult;
import java.nio.file.filevisitor;
import java.nio.file.files;
import java.nio.file.path;
import java.nio.file.path;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAtTributes;
import java.util.arrayList;
import java.util.list;
import com.xyq.io.enums.filetypemode;
import com.xyq.io.enums.optionfile_type;
import com.xyq.io.inf.newnioinf;
import com.xyq.io.util.findfileUtil;
import com.xyq.io.util.md5util;
clase pública Newnio implementa NewnioInf {
/***
* Copiar o mover archivos
*/
@Anular
public boolean CopeormoveFile (String Src, String Tar, OptionFile_Type Type) {
devolver realCopeormoveFile (raths.get (src), tar, tipo);
}
REALCOPOMOGO REALCOPOMOVE PRIVADO (PATH SRCPATH, alquitrán de cuerda,
OpcionFile_Type Type) {
Ruta lona = nulo;
boolean copesuccess = true;
// El archivo original debe existir
if (srcpath.tofile (). exists ()) {
/***
* Si se corta la ruta original, entonces se considera una carpeta
*/
if (isDir (tar))
Tarpath = Paths.get (tar + file.separator
+ srcpath.tofile (). getName ());
demás
lona = raths.get (tar);
/***
* Luego, realice n Times (se puede usar como parámetros) Operación de copia (Reconexión después del error), si sobrescribe la copia, el atributo de copia, la operación de copia no puede usar la opción de reversión
*/
para (int i = 0; i <3; i ++) {
/***
* Si el archivo de destino ya existe
*/
if (tarpath.tofile (). exists ()) {
/***
* Si verifica que las dos carpetas sean las mismas, no necesita copiar debajo de la opción Copiar.
*/
// Copiar
if (optionFile_type.cope.equals (type)) {
if (equalsfile (srcpath.tofile (), tarpath.tofile ())))
devolver verdadero;
demás
copesuccess = CopeFile (srcpath, lona, verdadero);
}
/***
* Mueve la operación, tenga mucho cuidado aquí.
* Luego, simplemente elimine el archivo original. Sin embargo, si los dos archivos son los mismos y la dirección también es
* Si es lo mismo, el original no se puede eliminar porque es el mismo archivo y no se puede eliminar.
*/
else if (optionFile_Type.move.equals (type)) {
if (equalsfile (srcpath.tofile (), tarpath.tofile ())) {
if (! srcpath.tofile (). getabsolutefile ())
.Equals (tarpath.tofile (). getabsolutefile ()))
intentar {
Files.delete (srcpath);
/***
* La razón para señalar a verdadero manualmente es que puede haber una falla en la eliminación previa.
*/
if (! co -cofesuccess)
copesuccess = true;
} Catch (ioException e) {
copesuccess = false;
}
// No regreso directamente porque hay una excepción en el frente, solo hazlo aquí
demás
devolver verdadero;
} demás
copesuccess = MoveFile (srcpath, lona);
}
}
/***
* Cuando el archivo de destino no existe, primero determine si se puede crear la carpeta de clase principal (la carpeta de clase principal existe o se puede crear), y luego cree cuando se pueda crear.
*/
demás {
Archivo par = tarpath.getParent (). Tofile ();
/***
* Si la carpeta de clase principal no existe y no se puede crear, entonces no hay necesidad de copiarla
*/
if (! par.exists () &&! par.mkdirs ())
copesuccess = false;
else if (optionFile_Type.cope.equals (type))
copesuccess = CopeFile (srcpath, lona, falso);
else if (optionFile_Type.move.equals (type))
copesuccess = MoveFile (srcpath, lona);
}
// Si la operación es exitosa, el bucle se saltará
if (copesuccess)
romper;
}
} demás
copesuccess = false;
devolver copesucces;
}
/***
* Copiar el archivo
*/
Copefile de Cope Booleano privado (Path Srcpath, Path Tarpath, boolean isexist) {
if (isExist)
intentar {
Files.copy (srcpath, lona,
StandardCopyOption.replace_Existing,
StandardCopyOption.Copy_Attributes);
} Catch (ioException e) {
devolver falso;
}
demás
intentar {
Files.copy (srcpath, tona, StandardCopyOption.Copy_Attributes);
} Catch (ioException e) {
devolver falso;
}
devolver verdadero;
}
/***
* Mover archivos, no se pueden usar opciones de atributo
*
* @param srcpath
* @param lona
* @devolver
*/
MOVE MOVE MOVO BOOLEA PRIVADO (PATH SRCPATH, PATH TARPATH) {
intentar {
Files.move (srcpath, lona, StandardCopyOption.Atomic_move);
} Catch (ioException e) {
devolver falso;
}
devolver verdadero;
}
/***
* Determinar si la ruta de ruta es una carpeta
*
* @param ruta
* @devolver
*/
booleano privado isdir (ruta de cadena) {
char Lastc = Path.Charat (Path.Length () - 1);
if (lastc == '//' || lastc == '/')
devolver verdadero;
devolver falso;
}
/***
* Esto es para verificar si los dos archivos son los mismos, es solo una verificación simple y puede verse obligado a usar MD5 para la verificación.
*/
Public Boolean EqualsFile (File Src, File Tar) {
// Si las longitudes de los dos archivos son diferentes, entonces los dos archivos son definitivamente diferentes
if (src.length ()! = tar.length ())
devolver falso;
if (! src.getName (). Equals (tar.getName ())
|| src.lastModified ()! = tar.lastModified ())
return md5util.encoderfileBymd5 (SRC) .equals (
Md5util.encoderfileBymd5 (tar));
devolver verdadero;
}
/***
* Copiar o mover carpetas
*/
@Anular
Vacío público COPEormOvedIrectory (String Src, Tar final de cadena, int Tiersize,
Tipo de opción final_type final) {
if (! New File (SRC) .Exists ())
tirar nueva runtimeException ("carpeta original no encontrada" + src);
final int rootPOS = getRootPosition (nuevo archivo (SRC), Tiersize);
if (rootpos! = -1) {
intentar {
Files.walkfiletree (ratts.get (src), nuevo fileVisitor <Thath> () {
Cadena TARDIRSTRING = NULL;
/***
* Antes de llegar a la carpeta, escriba primero la ruta de destino
*
* @param dir
* @param attrs
* @devolver
* @throws ioexception
*/
@Anular
Public FileVisitResult PrevisitDirectory (Path Dir,
BasicFileAtTributes attrs) lanza ioexception {
tardirstring = dir.tofile (). getAbSolutePath ();
Tardirstring = Tar + Tardirstring.substring (roadpos)
+ File.separator;
return FileVisitresult.Continue;
}
/***
* Después de llegar al archivo, copiarlo o moverlo
*
* @Param File
* @param attrs
* @devolver
* @throws ioexception
*/
@Anular
Public FileVisitresult VisitFile (archivo de ruta,
BasicFileAtTributes attrs) lanza ioexception {
Archivo f = file.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ())
RealCopeormoveFile (archivo, tardirstring, type);
return FileVisitresult.Continue;
}
@Anular
Public FileVisitresult VisitFileFailed (archivo de ruta,
Ioexception exc) lanza ioexception {
return FileVisitresult.Continue;
}
/***
* Después de llegar a la carpeta
*
* @param dir
* @param excc
* @devolver
* @throws ioexception
*/
@Anular
Public FileVisitresult PostVISITDirectory (Path Dir,
Ioexception exc) lanza ioexception {
return FileVisitresult.Continue;
}
});
} Catch (Exception e) {
E.PrintStackTrace ();
}
// Si es una operación de corte y el corte es exitoso, entonces debe eliminar todas las carpetas
if (optionFile_type.move.equals (type) && isblockdir (src)))
deldir (src);
} demás
tirar nueva runtimeException ("Especificar el error de la jerarquía de la carpeta de la clase principal ~~~");
}
/***
* Obtener la ubicación de la carta de unidad especificada de acuerdo con el nivel especificado
*/
Private int getRootPosition (archivo de archivo, int nivel) {
if (file! = null) {
String path = file.getabsolutePath ();
int cc = 0;
para (int i = path.length ()-1; i> = 0; i--) {
if (path.charat (i) == '//') {
cc ++;
if (cc == nivel + 1) {
cc = i;
devolver cc;
}
}
}
}
regreso -1;
}
/***
* Compruebe si hay algún archivo en esta carpeta
*
* @param dirpath
* @devolver
*/
ISBLOCKDIR ISBLOCKDIR PRIVADO (STRING DIRPATH) {
Archivo dir = nuevo archivo (dirpath);
Archivo [] dirlist = dir.listFiles ();
if (dirlist == null || dirlist.length == 0)
devolver verdadero;
demás {
// Buscar archivos
para (archivo f: dirlist)
if (! F.IsDirectory ())
devolver falso;
}
devolver verdadero;
}
/***
* Eliminar carpetas vacías
*
* @param dirpath
*/
Vacío privado deldir (String DirPath) {
Archivo dir = nuevo archivo (dirpath);
Archivo [] dirlist = dir.listFiles ();
if (dirlist == null || dirlist.length == 0)
dir.delete ();
demás {
// Eliminar todos los archivos
para (archivo f: dirlist)
if (F.ISDirectory ())
deldir (f.getabsolutePath ());
demás
F.Delete ();
// Eliminar la carpeta después de eliminar todos los archivos en la carpeta actual
dirlist = dir.listFiles ();
if (dirlist.length == 0)
dir.delete ();
}
}
/***
* Encuentra archivos relevantes basados en el tipo de archivo
*/
@Anular
Lista pública <String> FindFilesByType (String Dir, String [] teclas,
boolean ismatchcase) lanza ioexception {
List <String> list = new ArrayList <String> ();
Files.walkfiletree (raths.get (dir), nuevo findFileUtil (teclas, ismatchcase,
lista, filetypemode.types));
lista de devolución;
}
/***
* Encuentra archivos relevantes basados en el nombre del archivo
*/
@Anular
Lista pública <String> findFilesByName (String dir, string [] teclas,
boolean ismatchcase) lanza ioexception {
List <String> list = new ArrayList <String> ();
Files.walkfiletree (raths.get (dir), nuevo findFileUtil (teclas, ismatchcase,
lista, filetypemode.names));
lista de devolución;
}
public static void main (string [] args) lanza ioexception {
NewnioInf inf = new Newnio ();
inf.copeormoveFile ("e: /cc/dd/11.txt", "e:/xx/xxx/zzz/",
OpciónFile_Type.Cope);
inf.CopeormoDirectory ("e: // bb // cc // dd", "e: //", 1, optionFile_Type.move);
System.out.println (inf.FindFilesByName ("d: // workspace", nueva cadena [] {"txt"},
falso) .size ());
}
}
--------------------------------
paquete com.xyq.io.enums;
/***
* Tipo de archivo
* @author xyq
*
*/
public enum filetyPemode {
Tipos, nombres
}
---------------------------------
paquete com.xyq.io.enums;
/***
* Tipo de archivo de operación
* @author xyq
*
*/
Opción de enum public en enumfile_type {
Hacer frente, moverse;
}
-------------------------------------------------- -------------------------------------------------- ----------------------------
paquete com.xyq.io.inf;
import java.io.ioException;
import java.util.list;
import com.xyq.io.enums.optionfile_type;
interfaz pública NewnioInf {
/***
* Copiar o mover archivos
* @param src
* @param alquitrán
* @devolver
*/
público booleano CopeormoveFile (String Src, String Tar, OptionFile_Type Type);
/***
* Copiar o mover carpetas
* @param src
* @param alquitrán
* @param jerarquía de niveles, la ruta 0 Después de copiar es solo la carpeta actual, +1 significa agregar una carpeta de clase principal de primer nivel (pero no copiar el contenido de la clase principal)
* @param tipo
*/
public void CopeormoDirectory (string src, string tar, int tierize, optionFile_Type type);
/**
* Encuentre colecciones de archivos relevantes basadas en el tipo de archivo, separarlas con comas cuando múltiples tipos
*
* @param dir
* Tabla de contenido
* @Param Keys
* Tipo de archivo
* @param ismatchcase
* Si es sensible a la caja
* @devolver
* @throws ioexception
*/
Lista <String> findFilesByType (String dir, string [] teclas, boolean ismatchcase)
lanza ioexception;
/**
* Encuentre colecciones de archivos relevantes basadas en el nombre del archivo, separarlas con comas cuando múltiples términos civiles
*
* @param dir
* Tabla de contenido
* @Param Keys
* Nombre del archivo
* @param ismatchcase
* Si es sensible a la caja
* @devolver
* @throws ioexception
*/
Lista <String> findFilesByName (cadena dir, cadena [] teclas, boolean ismatchcase)
lanza ioexception;
}
---------------------
paquete com.xyq.io.util;
import java.io.file;
import java.io.ioException;
import java.nio.file.filevisitresult;
import java.nio.file.path;
import java.nio.file.simplefilevisitor;
import java.nio.file.attribute.BasicFileAtTributes;
import java.util.list;
import com.xyq.io.enums.filetypemode;
La clase pública FindFileUtil extiende SimpleFeLevisitor <Path> {
/***
* Lista de palabras clave, si se debe convertir el caso, devolver el conjunto de resultados
*/
cadena privada [] keyArray = null;
iSmatchcase privado booleano;
Lista privada <String> ResultList;
Modo privado FiletyPemode;
Public FindFileUtil (String [] KeyArray, boolean ismatchcase,
List <String> ResultList, FiletyPeMode Mode) {
this.KeyArray = KeyArray;
this.ismatchcase = ismatchcase;
this.ResultList = resultList;
this.mode = mode;
}
@SupessWarnings ("no usado")
Private findFileUtil () {
}
@Anular
Public FileVisitResult VisitFile (archivo de ruta, BasicFileAtTributes ATTRS)
lanza ioexception {
Archivo f = file.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ())
if (this.keyArray! = null) {
for (clave de cadena: this.keyArray) {
if (! this.ismitatchcase)
key = key.tolowerCase ();
if (matchFile (file, this.mode, key, ismatchcase))
resultList.Add (file.ToString ());
}
}
return FileVisitresult.Continue;
}
/***
* COMACIÓN DE ARCHIVO según el caso y el tipo o el nombre
*
* @Param File
* @Param Mode
* @Param Key
* @param ismatchcase
* @devolver
*/
Filito de combate booleano privado (archivo de ruta, modo filetypemode, tecla de cadena,
boolean ismatchcase) {
Archivo f = file.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ()
&&! "Información de volumen del sistema" .Equals (f.getName ())) {
Cadena filename = null;
if (filetypemode.types.equals (mode)) {
filename = file.ToString ();
devolver ismatchcase?
.tolowercase (). Endswith (clave);
} else if (filetypemode.names.equals (mode)) {
filename = file.tofile (). getName ();
return ismatchcase?
: verdadero)
: (FileName.TolowerCase (). IndexOf (Key) == -1? Falso
: verdadero);
}
}
devolver falso;
}
@Anular
Public FileVisitresult VisitFileFailed (archivo de ruta, IOException EXCC)
lanza ioexception {
// Si el mensaje de error contiene x:/información del volumen del sistema, esto significa el disco oculto del sistema y no se puede leer
System.out.println (exc.getMessage ());
return FileVisitresult.Continue;
}
}
--------------------------------
paquete com.xyq.io.util;
import java.io.Closable;
clase pública CloseIoutil {
/***
* Cerrar la transmisión IO
*
* @param CLS
*/
Closeall void estático público (cierre ... CLS) {
if (cls! = null) {
para (CL CLS: CLS) {
intentar {
if (cl! = nulo)
cl.close ();
} Catch (Exception e) {
} finalmente {
cl = nulo;
}
}
}
}
}
-------------------------------------------------- -------------------------------------------------- ----------------------------
paquete com.xyq.io.util;
import java.io.bufferedInputStream;
import java.io.file;
import java.io.fileInputStream;
import java.io.ioException;
import java.io.unsupportedencodingException;
import java.security.MessageGest;
import java.security.nosuchalgorithmexception;
import sun.misc.base64Encoder;
Clase pública MD5UTIL {
/***
* Cadena cifrada
*
* @param str
* @devolver
* @throws nosuchalgorithmexception
* @throws UnsupportedEncodingException
*/
Cadena estática pública EncoderStringByMd5 (String STR)
lanza nosuchalgorithmexception, no comportedEncodingException {
// Determinar el método de cálculo
MessageDigest MD5 = MessageGest.getInstance ("MD5");
Base64Encoder base64en = new Base64Encoder ();
// cadena cifrada
String Newsr = Base64en.Encode (MD5.Digest (str.getBytes ("UTF-8")));
Return Newsr;
}
/***
* Archivos cifrados
*
* @Param File
* @devolver
* @throws nosuchalgorithmexception
* @throws ioexception
*/
public static String EncoderFileByMd5 (archivo de archivo) {
String Newsstr = Null;
FileInputStream fis = null;
BufferedinputStream bis = null;
intentar {
// Determinar el método de cálculo
MessageDigest MD5 = MessageGest.getInstance ("MD5");
Base64Encoder base64en = new Base64Encoder ();
byte [] buffer = new Byte [1024];
fis = nuevo fileInputStream (archivo);
bis = new BufferedInputStream (FIS);
int longitud = -1;
while ((longitud = bis.read (buffer))! = -1)
md5.update (búfer, 0, longitud);
// cadena cifrada
Newsstr = Base64en.Encode (MD5.Digest ());
} Catch (Exception e) {
E.PrintStackTrace ();
} finalmente {
CloseIoutil.Closeall (bis, fis);
}
Return Newsr;
}
Public static void main (string [] args) lanza NosuchalgorithMexxception, no compatible encodingexception {
System.out.println (EncoderStringByMd5 ("23"));
}
}