La copie de code est la suivante:
package com.xyq.io.simply.core;
Importer java.io.file;
Importer java.io.ioException;
import java.nio.file.filevisiResult;
import java.nio.file.filevisitor;
import java.nio.file.files;
import java.nio.file.path;
import java.nio.file.paths;
Importer java.nio.file.standardCopyOption;
Importer java.nio.file.attribute.basicFileAtTributes;
import java.util.arraylist;
Importer 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;
classe publique newnio implémente newnioinf {
/ ***
* Copier ou déplacer des fichiers
* /
@Outrepasser
public boolean copeormovefile (chaîne src, string tar, optionfile_type type) {
return realcopeorMoveFile (paths.get (src), tar, type);
}
Private Boolean RealcopeorMoveFile (Path Srcpath, String Tar,
Type d'optionfile_type) {
PATH TARPATH = NULL;
Boolean CateCesuss = True;
// Le fichier d'origine doit exister
if (srcpath.tofile (). existe ()) {
/ ***
* Si le chemin d'origine est réduit, alors il est considéré comme un dossier
* /
if (isdir (tar))
tarpath = paths.get (tar + file.separator
+ srcpath.tofile (). getName ());
autre
tarpath = checks.get (TAR);
/ ***
* Ensuite, effectuez N fois (peut être utilisé comme paramètres) Copier l'opération (reconnection après l'erreur), s'il faut écraser la copie, copier l'attribut, la copie de l'opération ne peut pas utiliser l'option Rollback
* /
pour (int i = 0; i <3; i ++) {
/ ***
* Si le fichier cible existe déjà
* /
if (tarpath.tofile (). existant ()) {
/ ***
* Si vous vérifiez que les deux dossiers sont les mêmes, vous n'avez pas besoin de copier sous l'option de copie.
* /
// Copier
if (optionfile_type.cope.equals (type)) {
if (equalsfile (srcpath.tofile (), tarpath.tofile ()))
Retour Vrai;
autre
COPESUCESS = COPEFILE (SRCPATH, TARPATH, TRUE);
}
/ ***
* Déplacer le fonctionnement, soyez très prudent ici.
* Ensuite, supprimez simplement le fichier d'origine. Cependant, si les deux fichiers sont les mêmes et que l'adresse est également
* Si c'est le même, alors celui d'origine ne peut pas être supprimé car il s'agit du même fichier et ne peut pas être supprimé.
* /
else if (optionfile_type.move.equals (type)) {
if (equalsfile (srcpath.tofile (), tarpath.tofile ())) {
if (! srcpath.tofile (). getAbsoluteFile ())
.equals (tarpath.tofile (). getAbsoluteFile ()))
essayer {
Files.delete (srcPath);
/ ***
* La raison de pointer manuellement est qu'il peut y avoir un échec dans la suppression précédente.
* /
if (! coceceCess)
COPESUCCESS = true;
} catch (ioexception e) {
COPESUCESSS = FALSE;
}
// Je ne reviens pas directement car il y a une exception à l'avant, faites-le ici
autre
Retour Vrai;
} autre
CateSuCcess = movefile (srcpath, tarpath);
}
}
/ ***
* Lorsque le fichier cible n'existe pas, déterminez d'abord si le dossier de classe parent peut être créé (le dossier de classe parent existe ou peut être créé), puis le créer lorsqu'il peut être créé.
* /
autre {
Fichier par = tarpath.getparent (). Tofile ();
/ ***
* Si le dossier de classe parent n'existe pas et ne peut pas être créé, il n'est pas nécessaire de le copier
* /
if (! Par.exists () &&! Par.mkDirs ())
COPESUCESSS = FALSE;
else if (optionfile_type.cope.equals (type))
COPESUCESS = CoPefile (SrcPath, Tarpath, False);
else if (optionfile_type.move.equals (type))
CateSuCcess = movefile (srcpath, tarpath);
}
// Si l'opération réussit, la boucle sera sautée
if (copésuise)
casser;
}
} autre
COPESUCESSS = FALSE;
retour de copésalité;
}
/ ***
* Copiez le fichier
* /
coopére coléen privé (chemin srcpath, path tarpath, booléen isexist) {
si (isexist)
essayer {
Files.copy (srcpath, tarpath,
StandardCopyOption.replace_existing,
StandardCopyOption.copy_Attributes);
} catch (ioexception e) {
retourne false;
}
autre
essayer {
Files.copy (srcpath, tarpath, standardCopyOption.copy_attributes);
} catch (ioexception e) {
retourne false;
}
Retour Vrai;
}
/ ***
* Déplacer des fichiers, aucune option d'attribut ne peut être utilisée
*
* @param srcpath
* @param tarpath
* @retour
* /
Private Boolean MoveFile (Path SrcPath, Path Tarpath) {
essayer {
Files.move (srcpath, tarpath, standardcopyOption.atomic_move);
} catch (ioexception e) {
retourne false;
}
Retour Vrai;
}
/ ***
* Déterminez si le chemin du chemin est un dossier
*
* chemin @param
* @retour
* /
booléen privé (chemin de chaîne) {
char lastc = path.charat (path.length () - 1);
if (lastc == '//' || lastc == '/')
Retour Vrai;
retourne false;
}
/ ***
* Il s'agit de vérifier si les deux fichiers sont les mêmes, c'est juste une vérification simple, et il peut être obligé d'utiliser MD5 pour la vérification
* /
public booléen equalsfile (fichier src, fichier tar) {
// Si les longueurs des deux fichiers sont différentes, alors les deux fichiers sont définitivement différents
if (src.length ()! = tar.length ())
retourne false;
if (! src.getName (). equals (tar.getName ())
|| src.lastModified ()! = Tar.LastModified ())
retour md5util.encoderfilebymd5 (src) .Equals (
MD5Util.EncoderFileByMd5 (TAR));
Retour Vrai;
}
/ ***
* Copier ou déplacer les dossiers
* /
@Outrepasser
public void copeorovedIrctory (String src, fiche finale de String Tar, int tirsize,
Final OptionFile_Type Type) {
if (! nouveau fichier (src) .exists ())
lancer un nouveau RuntimeException ("dossier original introuvable" + src);
final int rootpos = getRootPosition (nouveau fichier (src), tiersize);
if (rootpos! = -1) {
essayer {
Files.walkFileTree (paths.get (src), new FileVisitor <athat> () {
String tardirString = null;
/ ***
* Avant d'arriver dans le dossier, écrivez d'abord le chemin cible
*
* @param dir
* @param attrs
* @retour
* @throws ioexception
* /
@Outrepasser
Public FilevisitResult Prévisitdirectory (Path Dir,
BasicFileAtTributes attrs) lève ioException {
TARDIRSTRING = dir.tofile (). getAbSolutepath ();
TARDIRSTRING = TAR + TARDIRSTRING.SUBSTRING (ROOTPOS)
+ File.separator;
return fileVisitResult.continue;
}
/ ***
* Après votre arrivée au fichier, copiez-le ou déplacez-le
*
* fichier @param
* @param attrs
* @retour
* @throws ioexception
* /
@Outrepasser
Public FileVisitResult VisitFile (fichier de chemin,
BasicFileAtTributes attrs) lève ioException {
File f = file.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ())
realcopeorMoveFile (fichier, tarrstring, type);
return fileVisitResult.continue;
}
@Outrepasser
public FileVisitResult VisitFileFailed (Fichier Path,
IOException exc) lève IOException {
return fileVisitResult.continue;
}
/ ***
* Après son arrivée au dossier
*
* @param dir
* @param excc
* @retour
* @throws ioexception
* /
@Outrepasser
FilevisiResult PostVisitDirectory public (Path Dir,
IOException exc) lève IOException {
return fileVisitResult.continue;
}
});
} catch (exception e) {
e.printStackTrace ();
}
// S'il s'agit d'une opération de coupe et que la coupe est réussie, vous devez supprimer tous les dossiers
if (optionFile_type.move.equals (type) && isBlockDir (src))
Deldir (SRC);
} autre
lancer une nouvelle RuntimeException ("Spécifier l'erreur de hiérarchie du dossier de classe parent ~~~");
}
/ ***
* Obtenez l'emplacement de la lettre d'entraînement spécifiée en fonction du niveau spécifié
* /
private int GetrootPosition (fichier de fichier, Int Tier) {
if (file! = null) {
String path = file.getabsolutepath ();
int cc = 0;
for (int i = path.length () - 1; i> = 0; i--) {
if (path.charat (i) == '//') {
CC ++;
if (cc == Tier + 1) {
cc = i;
retour CC;
}
}
}
}
retour -1;
}
/ ***
* Vérifiez s'il y a des fichiers dans ce dossier
*
* @param dirpath
* @retour
* /
booléen privé iSblockdir (String dirpath) {
Fichier dir = nouveau fichier (dirpath);
File [] dirlist = dir.listFiles ();
if (Dirlist == null || dirlist.length == 0)
Retour Vrai;
autre {
// trouver des fichiers
pour (fichier F: Dirlist)
if (! f.isdirectory ())
retourne false;
}
Retour Vrai;
}
/ ***
* Supprimer les dossiers vides
*
* @param dirpath
* /
void privé deldir (String dirpath) {
Fichier dir = nouveau fichier (dirpath);
File [] dirlist = dir.listFiles ();
if (Dirlist == null || dirlist.length == 0)
dir.delete ();
autre {
// Supprimer tous les fichiers
pour (fichier F: Dirlist)
if (f.isdirectory ())
Deldir (f.getabsolutepath ());
autre
f.delete ();
// Supprimer le dossier après avoir supprimé tous les fichiers dans le dossier actuel
Dirlist = dir.ListFiles ();
if (Dirlist.length == 0)
dir.delete ();
}
}
/ ***
* Trouver des fichiers pertinents en fonction du type de fichier
* /
@Outrepasser
Liste publique <string> findFilesByType (string dir, string [] touches,
Boolean IsmatchCase) lève IOException {
List <string> list = new ArrayList <string> ();
Files
list, filetypeMode.Types));
Liste de retour;
}
/ ***
* Trouvez des fichiers pertinents en fonction du nom du fichier
* /
@Outrepasser
Liste publique <string> findFilesByName (string dir, string [] touches,
Boolean IsmatchCase) lève IOException {
List <string> list = new ArrayList <string> ();
Files
list, filetypeMode.Names));
Liste de retour;
}
public static void main (String [] args) lance ioException {
Newnioinf inf = new newnio ();
inf.copeormovefile ("e: /cc/dd/11.txt", "e: / xx / xxx / zzz /",
OptionFile_type.cope);
inf.copeorMovedIrectory ("e: // bb // cc // dd", "e: //", 1, optionfile_type.move);
System.out.println (inf.FindFilesByName ("d: // workspace", new String [] {"txt"},
false) .size ());
}
}
--------------------------------
package com.xyq.io.enums;
/ ***
* Type de fichier
* @author xyq
*
* /
enum public filetypeMode {
Types, noms
}
---------------------------------
package com.xyq.io.enums;
/ ***
* Type de fichier d'opération
* @author xyq
*
* /
public enum optionfile_type {
Cope, bouger;
}
-------------------------------------------------- -------------------------------------------------- ----------------------------
package com.xyq.io.inf;
Importer java.io.ioException;
Importer java.util.list;
import com.xyq.io.enums.optionfile_type;
interface publique newnioinf {
/ ***
* Copier ou déplacer des fichiers
* @param src
* @param tar
* @retour
* /
public boolean copeormovefile (chaîne src, string Tar, optionfile_type type);
/ ***
* Copier ou déplacer les dossiers
* @param src
* @param tar
* Hiérarchie @param tiersize, le chemin 0 après la copie n'est que le dossier actuel, +1 signifie ajouter un dossier de classe parent de premier niveau (mais ne pas copier le contenu de la classe parent)
* Type @param
* /
public void CopeorovedIrctory (String SRC, String Tar, int tirsize, optionFile_type type);
/ **
* Trouvez des collections de fichiers pertinentes en fonction du type de fichier, séparez-les avec des virgules lorsque plusieurs types
*
* @param dir
* Table des matières
* @param clés
* Type de fichier
* @param Ismatchcase
* Que ce soit sensible à la casse
* @retour
* @throws ioexception
* /
List <string> findFilesByType (string dir, string [] touches, booléen ismatchcase)
lance ioException;
/ **
* Trouvez des collections de fichiers pertinentes en fonction du nom du fichier, séparez-les avec des virgules lorsque plusieurs termes civils
*
* @param dir
* Table des matières
* @param clés
* Nom de fichier
* @param Ismatchcase
* Que ce soit sensible à la casse
* @retour
* @throws ioexception
* /
List <string> findFilesByName (String dir, string [] touches, booléen ismatchcase)
lance ioException;
}
---------------------
package com.xyq.io.util;
Importer java.io.file;
Importer java.io.ioException;
import java.nio.file.filevisiResult;
import java.nio.file.path;
Importer java.nio.file.simpleFileVisitor;
Importer java.nio.file.attribute.basicFileAtTributes;
Importer java.util.list;
import com.xyq.io.enums.fileTypeMode;
classe publique FindFileutil étend SimpleFileVisitor <atham> {
/ ***
* Liste des mots clés, s'il faut convertir le cas, renvoyer le jeu de résultats
* /
String privé [] keyArray = null;
Ismatchcase booléen privé;
Liste privée <string> resultList;
Mode Privé FileTypeMode;
Public FindFileutil (String [] KeyArray, Boolean Ismatchcase,
List <string> resultList, mode filetypeMode) {
this.KeyArray = keyArray;
this.ismatchCase = IsmatchCase;
this.resultList = resultList;
this.mode = mode;
}
@SuppressWarnings ("inutilisé")
FindFileUtil privé () {
}
@Outrepasser
Public FileVisitResult VisitFile (fichier path, BasicFileAtTributes Attrs)
lance iOException {
File f = file.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ())
if (this.KeyArray! = null) {
for (String Key: this.KeyArray) {
if (! this.ismatchcase)
key = key.tolowercase ();
if (matchfile (fichier, this.mode, key, ismatchcase)))
resultList.add (file.toString ());
}
}
return fileVisitResult.continue;
}
/ ***
* Fichier correspondant basé sur le cas et le type ou le nom
*
* fichier @param
* Mode @param
* clé @param
* @param Ismatchcase
* @retour
* /
Private Boolean MatchFile (fichier path, mode filetypeMode, clé de chaîne,
booléen ismatchcase) {
File f = file.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ()
&&! "Informations sur le volume du système" .equals (f.getName ())) {
String filename = null;
if (filetypeMode.types.equals (mode)) {
filename = file.toString ();
Retour IsmatchCase?
.TolowerCase (). Endswith (clé);
} else if (filetypeMode.Names.equals (mode)) {
filename = file.tofile (). getName ();
return isMatchCase?
: vrai)
: (filename.tolowercase (). indexof (key) == -1? false
: vrai);
}
}
retourne false;
}
@Outrepasser
public FileVisitResult VisitFileFailed (fichier path, ioException excc)
lance iOException {
// Si le message d'erreur contient des informations X: / Volume du système, cela signifie le disque caché du système et ne peut pas être lu
System.out.println (exc.GetMessage ());
return fileVisitResult.continue;
}
}
--------------------------------
package com.xyq.io.util;
importer java.io.closeable;
classe publique Closeioutil {
/ ***
* Fermer le flux IO
*
* @param CLS
* /
Public statique vide fermeall (clôtuable ... CLS) {
if (cls! = null) {
pour (closable cl: cls) {
essayer {
if (cl! = null)
cl.close ();
} catch (exception e) {
} enfin {
cl = null;
}
}
}
}
}
-------------------------------------------------- -------------------------------------------------- ----------------------------
package com.xyq.io.util;
Importer java.io.BufferedInputStream;
Importer java.io.file;
import java.io.fileInputStream;
Importer java.io.ioException;
Importer java.io.UNSUPPORTEDENCODINGException;
Importer Java.Security.MessagediGest;
importer java.security.nosuchalgorithMexception;
Import Sun.Misc.Base64Encoder;
classe publique md5util {
/ ***
* Chaîne cryptée
*
* @param str
* @retour
* @throws noSuchalgorithMexception
* @Throws UnportEdenCodingException
* /
Encoderstringbymd5 de chaîne statique publique (String STR)
lance nosuchalgorithmexception, unpottedencodingException {
// déterminer la méthode de calcul
MessagediGest MD5 = MessagediGest.getInstance ("MD5");
Base64Encoder Base64en = new Base64Encoder ();
// chaîne cryptée
String newsr = base64en.encode (md5.digest (str.getBytes ("utf-8")));
retour newsr;
}
/ ***
* Fichiers cryptés
*
* fichier @param
* @retour
* @throws noSuchalgorithMexception
* @throws ioexception
* /
EncoderfileByMD5 (fichier de fichier) public statique.
String newsstr = null;
FileInputStream fis = null;
BufferedInputStream bis = null;
essayer {
// déterminer la méthode de calcul
MessagediGest MD5 = MessagediGest.getInstance ("MD5");
Base64Encoder Base64en = new Base64Encoder ();
octet [] tampon = nouveau octet [1024];
fis = new FileInputStream (fichier);
bis = new BufferedInputStream (FIS);
int length = -1;
while ((longueur = bis.read (tampon))! = -1)
MD5.Update (tampon, 0, longueur);
// chaîne cryptée
newsstr = base64en.encode (md5.digest ());
} catch (exception e) {
e.printStackTrace ();
} enfin {
Closeioutil.closeall (bis, fis);
}
retour newsr;
}
public static void main (String [] args) lève des NosuchalgorithMexception, UnportEncodingException {
System.out.println (EncoderstringByMd5 ("23"));
}
}