A cópia do código é a seguinte:
pacote com.xyq.io.simply.core;
importar java.io.file;
importar java.io.ioException;
importar java.nio.file.fileVisitResult;
importar java.nio.file.filevisitor;
importar java.nio.file.files;
importar java.nio.file.path;
importar java.nio.file.paths;
importar java.nio.file.standardcopyOption;
importar java.nio.file.attribute.basicfileattributes;
importar java.util.arraylist;
importar java.util.list;
importação com.xyq.io.enums.filetyPemode;
importar com.xyq.io.enums.optionfile_type;
importação com.xyq.io.inf.newnioinf;
importação com.xyq.io.util.findfileUtil;
importação com.xyq.io.util.md5util;
classe pública Newnio implementa newnioinf {
/***
* Copiar ou mover arquivos
*/
@Override
public boolean copeormovefile (string src, string alcatrão, opçãofile_type tipo) {
retornar realcopeRorMoveFile (paths.get (src), alcatrão, tipo);
}
Private Boolean RealcopeRoveFile (Path Srcpath, String Tar,
OptionFile_Type Type) {
Caminho tarpath = nulo;
Copeseccess booleano = true;
// O arquivo original deve existir
if (srcpath.tofile (). existe ()) {
/***
* Se o caminho original for cortado, é considerado uma pasta
*/
If (Isdir (Tar))
tarpath = paths.get (tar + file.separator
+ srcpath.tofile (). getName ());
outro
tarpath = paths.get (tar);
/***
* Em seguida, execute N vezes (pode ser usado como parâmetros) Operação de cópia (reconexão após erro), seja para substituir a cópia, copiar o atributo, a operação de cópia não pode usar a opção Rollback
*/
for (int i = 0; i <3; i ++) {
/***
* Se o arquivo de destino já existir
*/
if (tarpath.tofile (). existe ()) {
/***
* Se você verificar se as duas pastas são as mesmas, não precisará copiar na opção Copiar.
*/
// cópia
if (optionfile_type.cope.equals (tipo)) {
if (EqualsFile (srcpath.tofile (), tarpath.tofile ()))
retornar true;
outro
copesuccess = copefile (srcpath, tarpath, true);
}
/***
* Mova a operação, tenha muito cuidado aqui.
* Em seguida, basta excluir o arquivo original. No entanto, se os dois arquivos forem iguais e o endereço também for
* Se for o mesmo, o original não pode ser excluído porque é o mesmo arquivo e não pode ser excluído.
*/
caso contrário, if (optionfile_type.move.equals (tipo)) {
if (EqualsFile (srcpath.tofile (), tarpath.tofile ())) {
if (! srcpath.tofile (). getabsolutefile ())
.Equals (Tarpath.tofile (). getAbsolutefile ()))
tentar {
Files.Delete (SRCPath);
/***
* A razão para apontar para o verdadeiro manualmente é que pode haver uma falha na exclusão anterior.
*/
if (! CopeSuccess)
copesuccess = true;
} catch (ioexception e) {
copesuccess = false;
}
// Eu não volto diretamente porque há uma exceção na frente, apenas faça aqui
outro
retornar true;
} outro
copesuccess = movefile (srcpath, tarpath);
}
}
/***
* Quando o arquivo de destino não existe, primeiro determine se a pasta da classe pai pode ser criada (a pasta da classe pai existe ou pode ser criada) e depois criá -la quando pode ser criada.
*/
outro {
Arquivo par = TarPath.getParent (). Tofile ();
/***
* Se a pasta da classe pai não existir e não poderá ser criada, não há necessidade de copiá -la
*/
if (! par.exists () &&! par.mkdirs ())
copesuccess = false;
caso contrário, if (optionfile_type.cope.equals (tipo))
copesuccess = copefile (srcpath, tarpath, false);
caso contrário, if (optionfile_type.move.equals (tipo))
copesuccess = movefile (srcpath, tarpath);
}
// Se a operação for bem -sucedida, o loop será saltado
IF (CopeSuccess)
quebrar;
}
} outro
copesuccess = false;
Retornar CopeSuccess;
}
/***
* Copie o arquivo
*/
Privado booleano copefile (Path SRCPath, Path Tarpath, Boolean isExist) {
se (isexist)
tentar {
Files.copy (srcpath, tarpath,
StandardCopyOption.replace_existing,
PadrãocopyOption.copy_attributes);
} catch (ioexception e) {
retornar falso;
}
outro
tentar {
Files.copy (srcpath, tarpath, standardcopyOption.copy_attributes);
} catch (ioexception e) {
retornar falso;
}
retornar true;
}
/***
* Mova arquivos, nenhuma opção de atributo pode ser usada
*
* @param srcpath
* @param tarpath
* @retornar
*/
PRIVADO BOOLEAN MOVELFILE (PATH SRCPATH, PATH TARPATH) {
tentar {
Files.move (srcpath, tarpath, standardcopyOption.atomic_move);
} catch (ioexception e) {
retornar falso;
}
retornar true;
}
/***
* Determine se o caminho é uma pasta
*
* @param caminho
* @retornar
*/
Isdir booleano privado (caminho da string) {
char lastc = path.charat (path.length () - 1);
if (lastc == '//' || lastc == '/')
retornar true;
retornar falso;
}
/***
* Isso é para verificar se os dois arquivos são iguais, é apenas uma verificação simples e pode ser forçada a usar o MD5 para verificação
*/
public boolean EqualsFile (Arquivo SRC, Arquivo Tar) {
// Se os comprimentos dos dois arquivos forem diferentes, os dois arquivos serão definitivamente diferentes
if (src.length ()! = Tar.Length ())
retornar falso;
if (! src.getName (). Equals (Tar.getName ())
||.
retornar md5util.encoderfileByMD5 (SRC) .Equals (
Md5util.EncoderfileByMd5 (TAR));
retornar true;
}
/***
* Copiar ou mover pastas
*/
@Override
public void copeormevedirectory (string src, string final, int tiersize,
Final OptionFile_Type Type) {
if (! novo arquivo (src) .exists ())
lançar a nova RuntimeTeException ("Pasta original não encontrada" + SRC);
final int rootpos = getRootPosition (novo arquivo (src), tiersize);
if (rootpos! = -1) {
tentar {
Files.walkfiletree (paths.get (src), new FileVisitor <TATH> () {
String tardirstring = null;
/***
* Antes de chegar à pasta, escreva o caminho alvo primeiro
*
* @param dir
* @param attrs
* @retornar
* @THOWSows IoException
*/
@Override
public fileVisitResult previsitDirectory (Path Dir,
BASICFILEATTRIBUTOS ATTRS) lança ioexception {
tardirstring = dir.tofile (). getAbsolutepath ();
tardirstring = tar + tardirstring.substring (rootpos)
+ File.separator;
retornar fileVisitResult.Continue;
}
/***
* Depois de chegar ao arquivo, copiar ou mover -o
*
* arquivo @param
* @param attrs
* @retornar
* @THOWSows IoException
*/
@Override
public fileVisitResult visitfile (arquivo de caminho,
BASICFILEATTRIBUTOS ATTRS) lança ioexception {
Arquivo f = file.tofile ();
if (f.Exists () && f.canread () &&! f.ishidden ())
realcopeRorMoveFile (arquivo, tardirstring, tipo);
retornar fileVisitResult.Continue;
}
@Override
public fileVisitResult VisitFileFailed (File Path,
Ioexception exc) lança ioexception {
retornar fileVisitResult.Continue;
}
/***
* Depois de chegar à pasta
*
* @param dir
* @param Excc
* @retornar
* @THOWSows IoException
*/
@Override
public fileVisitResult PostVisitDirectory (Path Dir,
Ioexception exc) lança ioexception {
retornar fileVisitResult.Continue;
}
});
} catch (Exceção e) {
E.PrintStackTrace ();
}
// Se for uma operação de corte e o corte é bem -sucedido, você precisa excluir todas as pastas
if (optionfile_type.move.equals (tipo) && isBlockdir (src))
Deldir (SRC);
} outro
lançar a nova RuntimeTimeException ("Especifique o erro de hierarquia da pasta da classe pai ~~~");
}
/***
* Obtenha a localização da letra de unidade especificada de acordo com o nível especificado
*/
private int getRootPosition (arquivo de arquivo, int -tier) {
if (arquivo! = null) {
String path = file.getabsolutepath ();
int cc = 0;
for (int i = path.length ()-1; i> = 0; i--) {
if (path.charat (i) == '//') {
cc ++;
if (cc == camada + 1) {
cc = i;
retornar CC;
}
}
}
}
retornar -1;
}
/***
* Verifique se existem arquivos nesta pasta
*
* @param dirpath
* @retornar
*/
private boolean isblockdir (string dirpath) {
Arquivo dir = novo arquivo (dirpath);
Arquivo [] Dirlist = Dir.ListFiles ();
if (Dirlist == NULL || Dirlist.Length == 0)
retornar true;
outro {
// Encontre arquivos
para (Arquivo F: Dirlist)
if (! f.isdirectory ())
retornar falso;
}
retornar true;
}
/***
* Exclua pastas vazias
*
* @param dirpath
*/
Deldir do vazio privado (String Dirpath) {
Arquivo dir = novo arquivo (dirpath);
Arquivo [] Dirlist = Dir.ListFiles ();
if (Dirlist == NULL || Dirlist.Length == 0)
Dir.Delete ();
outro {
// Exclua todos os arquivos
para (Arquivo F: Dirlist)
if (f.isdirectory ())
deldir (f.getabsolutepath ());
outro
f.Delete ();
// Exclua a pasta após excluir todos os arquivos na pasta atual
Dirlist = Dir.ListFiles ();
if (Dirlist.Length == 0)
Dir.Delete ();
}
}
/***
* Encontre arquivos relevantes com base no tipo de arquivo
*/
@Override
Lista pública <String> FindFilesByType (String Dir, String [] Keys,
boolean ismatchcase) lança ioexception {
List <String> list = new ArrayList <String> ();
Files.walkfiletree (paths.get (dir), novo findfileUtil (chaves, ismatchcase,
lista, filetyPemode.types));
lista de retorno;
}
/***
* Encontre arquivos relevantes com base no nome do arquivo
*/
@Override
Lista pública <String> FindFilesByName (String dir, String [] Keys,
boolean ismatchcase) lança ioexception {
List <String> list = new ArrayList <String> ();
Files.walkfiletree (paths.get (dir), novo findfileUtil (chaves, ismatchcase,
lista, filetyPemode.names));
lista de retorno;
}
public static void main (string [] args) lança ioexception {
Newnioinf inf = new newnio ();
inf.copeorMoveFile ("e: /cc/dd/11.txt", "e:/xx/xxx/zzz/",
Optionfile_type.cope);
inf.copeReMovedirectory ("e: // bb // cc // dd", "e: //", 1, optionfile_type.move);
System.out.println (inf.findfilesbyname ("d: // workspace", new string [] {"txt"},
falso) .size ());
}
}
----------------------------------
pacote com.xyq.io.enums;
/***
* Tipo de arquivo
* @Author XYQ
*
*/
public Enum FileTyPeMode {
Tipos, nomes
}
-----------------------------------
pacote com.xyq.io.enums;
/***
* Tipo de arquivo de operação
* @Author XYQ
*
*/
public enum optionfile_type {
Lidar, mova -se;
}
-------------------------------------------------------- -------------------------------------------------------- ------------------------------
pacote com.xyq.io.inf;
importar java.io.ioException;
importar java.util.list;
importar com.xyq.io.enums.optionfile_type;
interface pública newnioinf {
/***
* Copiar ou mover arquivos
* @param src
* @param tar
* @retornar
*/
public boolean copeormovefile (string src, string alcatrão, opçãofile_type tipo);
/***
* Copiar ou mover pastas
* @param src
* @param tar
* @param tiersize hierarquia, o caminho 0 após a cópia é apenas a pasta atual, +1 significa adicionar uma pasta de classe pai de primeiro nível (mas não copiar o conteúdo da classe pai)
* Tipo @param
*/
public void copeormevedirectory (string src, string alcatrão, int tiersize, opçãofile_type tipo);
/**
* Encontre coleções de arquivos relevantes com base no tipo de arquivo, separe -as com vírgulas quando vários tipos
*
* @param dir
* Índice
* @param chaves
* Tipo de arquivo
* @param ismatchcase
* Se é sensível ao caso
* @retornar
* @THOWSows IoException
*/
Lista <String> FindFilesByType (String dir, String [] Teclas, Boolean IsMatchCase)
lança ioexception;
/**
* Encontre coleções de arquivos relevantes com base no nome do arquivo, separe -as com vírgulas quando vários termos civis
*
* @param dir
* Índice
* @param chaves
* Nome do arquivo
* @param ismatchcase
* Se é sensível ao caso
* @retornar
* @THOWSows IoException
*/
Lista <String> FindFilesByName (String Dir, String [] Keys, Boolean IsMatchCase)
lança ioexception;
}
-----------------------
pacote com.xyq.io.util;
importar java.io.file;
importar java.io.ioException;
importar java.nio.file.fileVisitResult;
importar java.nio.file.path;
importar java.nio.file.simplefilevisitor;
importar java.nio.file.attribute.basicfileattributes;
importar java.util.list;
importação com.xyq.io.enums.filetyPemode;
classe pública FindFileUtil estende SimpleFileVisitor <TACH> {
/***
* Lista de palavras -chave, seja para converter o caso, o conjunto de resultados de retorno
*/
private string [] keyArray = null;
private boolean ismatchcase;
Lista privada <String> ResultList;
modo filetyPeMode privado;
public findfileUtil (String [] KeyArray, Boolean IsMatchCase,
Lista <String> ResultList, Modo FileTyPemode) {
this.KeyArray = keyArray;
this.ismatchCase = isMatchCase;
this.ResultList = resultadoList;
this.mode = mode;
}
@Suppresswarnings ("não utilizado")
Private FindFileUtil () {
}
@Override
public fileVisitResult VisitFile (arquivo de caminho, BASICFILEATTRIBUTOS ATTRS)
lança ioexception {
Arquivo f = file.tofile ();
if (f.Exists () && f.canread () &&! f.ishidden ())
if (this.keyarray! = null) {
para (chave da string: this.keyarray) {
if (! this.ismatchCase)
key = key.tolowerCase ();
if (matchFile (arquivo, this.mode, key, isMatchCase))
resultadolist.add (file.toString ());
}
}
retornar fileVisitResult.Continue;
}
/***
* Correspondência de arquivo com base no caso e tipo ou nome
*
* arquivo @param
* Modo @param
* @param chave
* @param ismatchcase
* @retornar
*/
PRIVADO BOOKEANFILE (FILE PATH, Modo FileTyPemode, Tecla de String,
IsMatchCase booleano) {
Arquivo f = file.tofile ();
if (f.Exists () && f.canread () &&! f.ishidden ()
&&! "Informações do volume do sistema" .equals (f.getName ())) {
String filename = null;
if (filetyPemode.types.equals (modo)) {
arquivo de arquivo = file.toString ();
Retorno isMatchCase?
.tolowerCase (). endswith (chave);
} else if (filetyPemode.names.equals (modo)) {
FILENAME = FILE.TOFILE (). getName ();
Retornar IsMatchCase?
: verdadeiro)
: (FILENAME.TOLOWERCase ().
: verdadeiro);
}
}
retornar falso;
}
@Override
public fileVisitResult VisitFileFailed (File Path, IoException Excc)
lança ioexception {
// Se a mensagem de erro contiver informações de volume x:/sistema, isso significa o disco oculto do sistema e não pode ser lido
System.out.println (exc.getMessage ());
retornar fileVisitResult.Continue;
}
}
----------------------------------
pacote com.xyq.io.util;
importar java.io.closable;
classe pública Closeioutil {
/***
* Feche o fluxo de io
*
* @param cls
*/
public static void Closetll (fechado ... cls) {
if (cls! = null) {
para (Cl: CLS) {
tentar {
se (cl! = nulo)
cl.close ();
} catch (Exceção e) {
} finalmente {
Cl = nulo;
}
}
}
}
}
-------------------------------------------------------- -------------------------------------------------------- ------------------------------
pacote com.xyq.io.util;
importar java.io.bufferInputStream;
importar java.io.file;
importar java.io.fileInputStream;
importar java.io.ioException;
importar java.io.unsupportEnCodingException;
importar java.Security.Messagedigest;
importar java.security.nosuchalgorithMexception;
importar sun.misc.base64Encoder;
classe pública md5util {
/***
* String criptografada
*
* @param str
* @retornar
* @THOWS NosuchalGorithMexception
* @THOWS UnsupportEdEncodingException
*/
public static string coderstringbymd5 (string str)
lança NosuchalgorithMexception, UnsupportEdEncodingException {
// determinar o método de cálculo
Messagedigest md5 = Messagedigest.getInstance ("md5");
Base64Encoder base64en = new base64Encoder ();
// string criptografada
String Newsr = base64en.encode (md5.digest (str.getBytes ("utf-8")));
retornar Newsr;
}
/***
* Arquivos criptografados
*
* arquivo @param
* @retornar
* @THOWS NosuchalGorithMexception
* @THOWSows IoException
*/
public static string coderfileByMd5 (arquivo de arquivo) {
Newsstr = nulo;
FileInputStream fis = null;
BufferInputStream bis = null;
tentar {
// determinar o método de cálculo
Messagedigest md5 = Messagedigest.getInstance ("md5");
Base64Encoder base64en = new base64Encoder ();
byte [] buffer = novo byte [1024];
fis = new FileInputStream (arquivo);
bis = new bufferinputStream (fis);
int length = -1;
while ((comprimento = bis.read (buffer))! = -1)
md5.Update (buffer, 0, comprimento);
// string criptografada
newsstr = base64en.encode (md5.digest ());
} catch (Exceção e) {
E.PrintStackTrace ();
} finalmente {
Closeioutil.CLOSEALL (bis, fis);
}
retornar Newsr;
}
public static void main (string [] args) lança NosuchalGorithMexception, UnsupportEdEncodingException {
System.out.println (coderstringbymd5 ("23"));
}
}