Die Codekopie lautet wie folgt:
Paket com.xyq.io.simply.core;
Import Java.io.file;
importieren java.io.ioException;
Import Java.nio.File.Filevisitresult;
Import Java.nio.File.Filevisor;
importieren java.nio.file.files;
Import Java.nio.file.Path;
Import Java.nio.file.Paths;
Import Java.nio.file.StandardCopyOption;
importieren java.nio.file.attribute.basicFileattributes;
Import Java.util.ArrayList;
importieren 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;
öffentliche Klasse Newnio implementiert Newnioinf {
/***
* Dateien kopieren oder verschieben
*/
@Override
public boolean CopeOrmoVeFile (String SRC, String Tar, OptionFile_Type -Typ) {
return realcopeOrtefile (paths.get (src), tar, type);
}
Private boolean RealcopeOrRoveFile (Path SrcPath, String Tar,
OptionFile_type Typ) {
Pfad Tarpath = NULL;
boolean copesuccess = true;
// Die Originaldatei muss existieren
if (srcpath.tofile (). exists ()) {
/***
* Wenn der ursprüngliche Pfad abgeschnitten wird, wird er als Ordner angesehen
*/
if (isdir (tar))
tarpath = paths.get (tar + file.separator
+ srcPath.toFile (). getName ());
anders
tarpath = paths.get (tar);
/***
* Führen Sie dann die n -mal (können als Parameter verwendet werden) Kopiervorgang (Wiederverbindung nach dem Fehler), ob das Kopieren von Kopien überschreibt, das Attribut kopieren kann, die Kopieroperation kann die Rollback -Option nicht verwenden
*/
für (int i = 0; i <3; i ++) {
/***
* Wenn die Zieldatei bereits vorhanden ist
*/
if (tarpath.tofile (). exist ()) {
/***
* Wenn Sie überprüfen, ob die beiden Ordner gleich sind, müssen Sie die Option Kopie nicht kopieren.
*/
// kopieren
if (optionFile_type.cope.equals (Typ)) {
if (Equalsfile (srcpath.tofile (), tarpath.tofile ()))
zurückkehren;
anders
copesuccess = copefile (srcPath, tarpath, true);
}
/***
* Seien Sie unter normalen Umständen sehr vorsichtig, wenn die beiden Dateien gleich sind.
* Löschen Sie dann einfach die Originaldatei. Wenn die beiden Dateien jedoch gleich sind und die Adresse auch ist
* Wenn es dasselbe ist, kann das Original nicht gelöscht werden, da es dieselbe Datei ist und nicht gelöscht werden kann.
*/
sonst if (optionFile_type.move.equals (Typ)) {
if (Equalsfile (srcpath.tofile (), tarpath.tofile ()) {
if (! srcpath.tofile (). getAbSoluteFile ())
.Equals (tarpath.tofile (). getAbSoluteFile ()))
versuchen {
Dateien.Delete (srcPath);
/***
* Der Grund für manuelles Hinweis auf True ist, dass es in der vorherigen Löschung zu einem Versagen besteht.
*/
if (! copesuccess)
copesuccess = true;
} catch (ioException e) {
copesuccess = false;
}
// Ich kehre nicht direkt zurück, weil vorne eine Ausnahme vorhanden ist. Mach es einfach hier
anders
zurückkehren;
} anders
Copesuccess = MoveFile (srcPath, Tarpath);
}
}
/***
* Wenn die Zieldatei nicht vorhanden ist, bestimmen Sie zunächst, ob der übergeordnete Klassenordner erstellt werden kann (der übergeordnete Klassenordner existiert oder erstellt werden kann), und erstellen Sie sie dann, wenn sie erstellt werden kann.
*/
anders {
Datei par = tarpath.getParent (). ToFile ();
/***
* Wenn der Ordner der übergeordneten Klassen nicht existiert und nicht erstellt werden kann, müssen sie nicht kopiert werden
*/
if (! par.Exists () &&! par.mkdirs ())
copesuccess = false;
sonst if (optionFile_type.cope.equals (Typ))
copesuccess = copefile (srcPath, Tarpath, Falsch);
sonst if (optionFile_type.move.equals (Typ))
Copesuccess = MoveFile (srcPath, Tarpath);
}
// Wenn die Operation erfolgreich ist, wird die Schleife herausgesprungen
if (copesuccess)
brechen;
}
} anders
copesuccess = false;
Copesuccess zurückgeben;
}
/***
* Kopieren Sie die Datei
*/
Private boolesche Copefile (Pfad SrcPath, Pfad Tarpath, boolean isexist) {
if (aSexist)
versuchen {
Dateien.Copy (SRCPath, Tarpath,
StandardCopyOption.Replace_EXISTING,,
StandardCopyOption.copy_attributes);
} catch (ioException e) {
false zurückgeben;
}
anders
versuchen {
Dateien.Copy (SrcPath, Tarpath, StandardCopyOption.copy_attributes);
} catch (ioException e) {
false zurückgeben;
}
zurückkehren;
}
/***
* Verschieben Sie Dateien, können keine Attributoptionen verwendet werden
*
* @param srcPath
* @param tarpath
* @zurückkehren
*/
private boolean movefile (Pfad srcPath, Pfad Tarpath) {
versuchen {
Dateien.Move (srcPath, Tarpath, StandardCopyOption.atomic_move);
} catch (ioException e) {
false zurückgeben;
}
zurückkehren;
}
/***
* Bestimmen Sie, ob der Pfad ein Ordner ist
*
* @param Pfad
* @zurückkehren
*/
private boolean isdir (String Pfad) {
char lastc = path.charat (path.length () - 1);
if (lastc == '//' || lastc == '/')
zurückkehren;
false zurückgeben;
}
/***
* Dies soll überprüfen
*/
public boolean equalsfile (Datei SRC, Datei tar) {
// Wenn die Längen der beiden Dateien unterschiedlich sind, sind die beiden Dateien definitiv unterschiedlich
if (src.length ()! = tar.length ())
false zurückgeben;
if (! src.getName (). Equals (tar.getName ())
||.
return md5util.encoderFileBYMD5 (SRC) .Equals (Ausgleich (
Md5util.encoderFileBYMD5 (tar));
zurückkehren;
}
/***
* Ordner kopieren oder verschieben
*/
@Override
Public void Copeormoved -Anlehnung (String SRC, Final String Tar, int Tiersize,
endgültige OptionFile_type Typ) {
if (! Neue Datei (SRC) .exists ())
Neue RunTimeException werfen ("Originalordner nicht gefunden" + SRC);
endgültig int rootPos = getrootPosition (neue Datei (SRC), Tiersize);
if (rootPos! = -1) {
versuchen {
Dateien.WalkFiletree (Paths.get (SRC), neuer Dateivisor <Path> () {
String tardirstring = null;
/***
* Schreiben Sie zuerst den Zielweg, bevor Sie im Ordner ankommen
*
* @param dir
* @param attrs
* @zurückkehren
* @throws ioException
*/
@Override
public Filevissitresult PrevisitDirectory (Path Dir,
BasicFileAttributes Attrs) löst ioException {aus
TARDIRSTRING = DIR.TOFILE (). getAbsolutepath ();
TARDIRSTRING = TAR + TARDIRSTRING.SUBSTRING (Wurzelpos)
+ Datei.Separator;
return FileVisVitResult.Continue;
}
/***
* Nachdem Sie in der Datei angekommen sind, kopieren Sie sie oder verschieben Sie sie
*
* @param Datei
* @param attrs
* @zurückkehren
* @throws ioException
*/
@Override
public Filevissitresult VisitFile (Pfaddatei,
BasicFileAttributes Attrs) löst ioException {aus
Datei f = Datei.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ())
RealcopeOrtFile (Datei, Tardirstring, Typ);
return FileVisVitResult.Continue;
}
@Override
public FilevisResult VisitFileFailed (Pfaddatei,
IoException exc) löst ioException {aus
return FileVisVitResult.Continue;
}
/***
* Nach der Ankunft im Ordner
*
* @param dir
* @param excc
* @zurückkehren
* @throws ioException
*/
@Override
public Filevissitresult postvisitdirectory (Path Dir,
IoException exc) löst ioException {aus
return FileVisVitResult.Continue;
}
});
} catch (Ausnahme e) {
E. printstacktrace ();
}
// Wenn es sich um einen Schnittbetrieb handelt und der Schnitt erfolgreich ist, müssen Sie alle Ordner löschen
if (optionFile_type.move.equals (Typ) && isblockdir (SRC))
Deldir (SRC);
} anders
Neue RunTimeException werfen ("Angeben Sie die Hierarchie -Fehlerklassen -Ordner -Fehler -Fehler ~~~");
}
/***
* Holen Sie sich den Standort des angegebenen Laufwerks gemäß der angegebenen Ebene
*/
private int getrootPosition (Dateidatei, int Tier) {
if (Datei! = null) {
String path = file.getabsolutepath ();
int cc = 0;
für (int i = path.length ()-1; i> = 0; i--) {
if (path.charat (i) == '//') {
CC ++;
if (cc == Tier + 1) {
cc = i;
CC zurückgeben;
}
}
}
}
Return -1;
}
/***
* Überprüfen Sie, ob in diesem Ordner Dateien enthalten sind
*
* @param Dirath
* @zurückkehren
*/
private boolean isblockdir (String Dirath) {
Datei Dir = New Datei (DirPath);
Datei [] dirlist = dir.Listfiles ();
if (dirlist == null || dirlist.length == 0)
zurückkehren;
anders {
// Dateien finden
für (Datei F: dirlist)
if (! f.isdirectory ())
false zurückgeben;
}
zurückkehren;
}
/***
* Leere Ordner löschen
*
* @param Dirath
*/
private void deldir (String Dirath) {
Datei Dir = New Datei (DirPath);
Datei [] dirlist = dir.Listfiles ();
if (dirlist == null || dirlist.length == 0)
Dir.Delete ();
anders {
// Alle Dateien löschen
für (Datei F: dirlist)
if (f.isdirectory ())
Deldir (f.getabsolutepath ());
anders
f.delete ();
// Löschen Sie den Ordner, nachdem Sie alle Dateien im aktuellen Ordner gelöscht haben
Dirlist = dir.Listfiles ();
if (dirlist.length == 0)
Dir.Delete ();
}
}
/***
* Finden Sie relevante Dateien basierend auf Dateityp
*/
@Override
öffentliche Liste <String> findFilesByType (String DIR, String [] Tasten,
boolean ismatchCase) löst ioException {aus
Liste <String> list = new ArrayList <string> ();
Dateien.WalkFiletree (Paths.get (DIR), New FindFileUtil (Schlüssel, IsmatchCase,
Liste, Filetypemode.types));
Rückgabeliste;
}
/***
* Finden Sie relevante Dateien basierend auf Dateinamen
*/
@Override
öffentliche Liste <String> findFilesByName (String DIR, String [] Tasten,
boolean ismatchCase) löst ioException {aus
Liste <String> list = new ArrayList <string> ();
Dateien.WalkFiletree (Paths.get (DIR), New FindFileUtil (Schlüssel, IsmatchCase,
Liste, Filetypemode.names));
Rückgabeliste;
}
public static void main (String [] args) löst ioException {aus
Newnioinf inf = new Newnio ();
Inf.CopeOrmoVeFile ("e: /cc/dd/11.txt", "e:/xx/xxx/zzz/",
OptionFile_type.cope);
Inf.CopeOmRovedIRectory ("e: // bb // cc // dd", "e: //", 1, optionFile_type.move);
System.out.println (inf.findFilesbyname ("d: // Workspace", neuer String [] {"txt"},
falsch) .size ());
}
}
--------------------------------
Paket com.xyq.io.enums;
/***
* Dateityp
* @Author xyq
*
*/
public Enum Filetypemode {
Typen, Namen
}
---------------------------------
Paket com.xyq.io.enums;
/***
* Art der Betriebsdatei
* @Author xyq
*
*/
public enum optionfile_type {
Umgehen, bewegen;
}
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------
Paket com.xyq.io.inf;
importieren java.io.ioException;
importieren java.util.list;
import com.xyq.io.enums.optionfile_type;
öffentliche Schnittstelle Newnioinf {
/***
* Dateien kopieren oder verschieben
* @param src
* @param tar
* @zurückkehren
*/
public boolean CopeOrmoVeFile (String SRC, String Tar, OptionFile_Type -Typ);
/***
* Ordner kopieren oder verschieben
* @param src
* @param tar
* @Param Tiersize-Hierarchie ist der Pfad 0 nach dem Kopieren nur der aktuelle Ordner, +1 bedeutet, einen übergeordneten Klassenordner der ersten Ebene hinzuzufügen (aber nicht den Inhalt der übergeordneten Klassenkopie).
* @param type
*/
public void CopeOmRovedirectory (String SRC, String tar, int liesize, OptionFile_Type -Typ);
/**
* Finden Sie relevante Dateisammlungen basierend auf Dateityp und trennen Sie sie bei mehreren Typen mit Kommas
*
* @param dir
* Inhaltsverzeichnis
* @param Keys
* Dateityp
* @param ismatchCase
* Ob es sich um fallempfindlich handelt
* @zurückkehren
* @throws ioException
*/
List <String> findFilesByType (String dir, String [] Tasten, boolean ismatchCase)
wirft ioException aus;
/**
* Finden Sie relevante Dateisammlungen basierend auf Dateinamen und trennen Sie sie mit Kommas, wenn mehrere zivile Begriffe
*
* @param dir
* Inhaltsverzeichnis
* @param Keys
* Dateiname
* @param ismatchCase
* Ob es sich um fallempfindlich handelt
* @zurückkehren
* @throws ioException
*/
List <String> findFilesByName (String dir, String [] Tasten, boolean ismatchCase)
wirft ioException aus;
}
---------------------
Paket com.xyq.io.util;
Import Java.io.file;
importieren java.io.ioException;
Import Java.nio.File.Filevisitresult;
Import Java.nio.file.Path;
Import Java.nio.File.SimpleFilevisor;
importieren java.nio.file.attribute.basicFileattributes;
importieren java.util.list;
import com.xyq.io.enums.filetypemode;
Die öffentliche Klasse FindFileUtil erweitert SimpleFilevisor <Path> {
/***
* Keyword -Liste, ob der Fall konvertiert werden soll, Rückgabeergebnissatz
*/
private String [] keyArray = null;
privat boolean ismatchCase;
private list <string> resultlist;
privater Filetypemode -Modus;
public findFileUtil (String [] KeyArray, Boolean IsmatchCase,
List <String> Ergebnisliste, Filetypemode -Modus) {
this.keyArray = keyArray;
this.isMatchCase = IsmatchCase;
this.resultlist = resultlist;
this.mode = modus;
}
@Suppresswarnings ("nicht genutzt")
private findFileUtil () {
}
@Override
public FilevisResult VisitFile (Pfaddatei, BasicFileAttributes Attrs)
löst ioException {aus
Datei f = Datei.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ())
if (this.keyArray! = null) {
für (String Key: this.keyArray) {
if (! this.isMatchCase)
key = key.tolowerCase ();
if (matchFile (Datei, this.mode, key, ismatchCase)))
resultList.add (file.toString ());
}
}
return FileVisVitResult.Continue;
}
/***
* Dateiübereinstimmung basierend auf Fall und Typ oder Namen
*
* @param Datei
* @param modus
* @param key
* @param ismatchCase
* @zurückkehren
*/
private boolean matchfile (Pfaddatei, Filetypemode -Modus, String -Taste,
boolean ismatchCase) {
Datei f = Datei.tofile ();
if (f.exists () && f.canread () &&! f.ishidden ()
&&! "Systemvolumeninformationen" .Equals (f.getName ())) {
String Dateiname = null;
if (Filetypemode.types.equals (Modus)) {
fileName = file.toString ();
IsmatchCase zurückgeben?
.TolowerCase (). Endswith (Schlüssel);
} else if (FiletypeMode.names.equals (Modus)) {
fileName = file.toFile (). getName ();
IsmatchCase zurückgeben? (Dateiname.indexof (Schlüssel) == -1?
: WAHR)
: (Dateiname.tolowerCase (). Indexof (Schlüssel) == -1? Falsch
: WAHR);
}
}
false zurückgeben;
}
@Override
public FilevisResult VisitFileFailed (Pfaddatei, IOException EXCC)
löst ioException {aus
// Wenn die Fehlermeldung X:/System -Volumeninformationen enthält, bedeutet dies die versteckte Scheibe des Systems und kann nicht gelesen werden
System.out.println (exc.getMessage ());
return FileVisVitResult.Continue;
}
}
--------------------------------
Paket com.xyq.io.util;
importieren java.io.closisable;
öffentliche Klasse CloseIoutil {
/***
* Schließen Sie den IO -Stream
*
* @param cls
*/
public static void tloseall (schließbar ... cls) {
if (cls! = null) {
für (schließbarer cl: cls) {
versuchen {
if (cl! = null)
Cl.CLOSE ();
} catch (Ausnahme e) {
} Endlich {
CL = NULL;
}
}
}
}
}
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------
Paket com.xyq.io.util;
import Java.io.BufferedInputStream;
Import Java.io.file;
import Java.io.FileInputStream;
importieren java.io.ioException;
importieren java.io.unsupportedenCodingException;
Java.Security.Messagedigest importieren;
Java.security.NoSuchalgorithmException;
import sun.misc.base64Encoder;
öffentliche Klasse Md5util {
/***
* Verschlüsselte Zeichenfolge
*
* @param str
* @zurückkehren
* @Throws NoSuchalgorithmException
* @Throws Uns SupportedenCodingException
*/
öffentliches statisches String -EncoderstringBYMD5 (String Str)
Wirft NoSuchalgorithmexception, nicht unterstütztEnencodingException {aus
// Bestimmen Sie die Berechnungsmethode
MessagedIGest MD5 = MessagedIGest.getInstance ("Md5");
Base64Encoder Base64en = new Base64EnenCoder ();
// verschlüsselte Zeichenfolge
String newsr = Base64en.Encode (md5.Digest (str.getBytes ("utf-8"));
return Newsr;
}
/***
* Verschlüsselte Dateien
*
* @param Datei
* @zurückkehren
* @Throws NoSuchalgorithmException
* @throws ioException
*/
public static String EncoderFileBYMD5 (Dateidatei) {
String Newsstr = null;
FileInputStream fis = null;
BufferedInputStream Bis = null;
versuchen {
// Bestimmen Sie die Berechnungsmethode
MessagedIGest MD5 = MessagedIGest.getInstance ("Md5");
Base64Encoder Base64en = new Base64EnenCoder ();
byte [] buffer = neues byte [1024];
fis = new FileInputStream (Datei);
Bis = neuer BufferedInputStream (FIS);
int länge = -1;
while ((Länge = Bis.read (Puffer))! = -1)
Md5.Update (Puffer, 0, Länge);
// verschlüsselte Zeichenfolge
newsStr = base64en.encode (md5.Digest ());
} catch (Ausnahme e) {
E. printstacktrace ();
} Endlich {
Closeioutil.closeAll (Bis, fis);
}
return Newsr;
}
public static void main (String [] args) löst NoSuchalgorithmException, nicht unterstütztEnencodingException {aus
System.out.println (ccoderstringBYMD5 ("23"));
}
}