Dieses Programm wurde nur entwickelt, um das Kopieren von Dateien (Ordnern) komfortabler zu machen.
1. Es ist nicht nötig, einen neuen Ordner zu erstellen, es ist so einfach wie Kopieren und Einfügen in Windows.
2. Es gibt einen einfachen Fehlerwiederverbindungsmechanismus
3. Keine Notwendigkeit, Kopien zu duplizieren oder Dateien differenziell zu kopieren.
4. Beim Kopieren eines Ordners müssen Sie nicht den vollständigen Pfad kopieren, sondern können sich nur auf den Ordner konzentrieren, der kopiert werden soll.
5. Das Programm führt einfache notwendige Prüfungen durch und die Effizienz ist nicht gering.
6. Die neue API von nio2 von 7 wird verwendet.
Kopieren Sie den Codecode wie folgt:
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.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
java.util.Stack importieren;
import org.apache.log4j.Logger;
import com.xyq.myfile.cope.entity.PathType;
import com.xyq.util.MD5Util;
/***
* Kopieralgorithmus basierend auf JDK7
*
* @author xyq
*
*/
öffentliche Klasse MyFiles2 {
private String src;
privater String tar;
privater Pfad srcPath;
privater Pfad tarPath;
private int reCount = 3;
privater boolescher Wert isCover = false;
privater boolescher Wert useMd5 = false;
private int subNameNum = 0;
// log4j-Objekt
privater Logger-Logger;
// Im Ordner-->Ordnermodus wird standardmäßig nicht kopiert, ob der vollständige Pfad kopiert werden soll
privater boolescher Wert isCopeAllPath = false;
public MyFiles2(String src, String tar) {
this.src = src;
this.tar = tar;
this.srcPath = Paths.get(src);
this.tarPath = Paths.get(tar);
}
public MyFiles2() {
}
öffentlicher String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
this.srcPath = Paths.get(src);
}
öffentlicher String getTar() {
Teer zurückgeben;
}
public void setTar(String tar) {
this.tar = tar;
this.tarPath = Paths.get(tar);
}
public int getReCount() {
return reCount;
}
public void setReCount(int reCount) {
this.reCount = reCount;
}
öffentlicher boolescher Wert isCover() {
return isCover;
}
public void setCover(boolean isCover) {
this.isCover = isCover;
}
öffentlicher Logger getLogger() {
Rücklauf-Logger;
}
public void setLogger(Logger logger) {
this.logger = logger;
}
öffentlicher boolescher Wert isUseMd5() {
return useMd5;
}
public void setUseMd5(boolean useMd5) {
this.useMd5 = useMd5;
}
öffentlicher boolescher Wert isCopeAllPath() {
return isCopeAllPath;
}
public void setCopeAllPath(boolean isCopeAllPath) {
this.isCopeAllPath = isCopeAllPath;
}
public boolean copeFileCore(PathType...types) {
if (initCheck() && initCheck2s(this.srcPath, false))
return copeFileCore(this.srcPath, this.tarPath, reCount, isCover,
Typen);
return false;
}
privater boolescher initCheck() {
if (this.srcPath == null) {
logInfo("Der ursprüngliche Pfad ist nicht festgelegt, das Programm kann nicht gestartet werden~~");
return false;
} else if (this.tarPath == null) {
logInfo("Der Zielpfad ist nicht festgelegt, das Programm kann nicht gestartet werden~~");
return false;
} else if (!Files.exists(srcPath)) {
logInfo("Der ursprüngliche Pfad existiert nicht, das Programm kann nicht gestartet werden~~");
return false;
} else if (!Files.exists(tarPath.getRoot())) {
logInfo("Der Root-Laufwerksbuchstabe des Zielpfads existiert nicht und das Programm kann nicht gestartet werden~~");
return false;
}
return true;
}
private boolean initCheck2s(Path path, boolean dOrF) {
if (!Files.isDirectory(path)) {
if (dOrF) {
logInfo(path + „kein gültiger Ordner“);
return false;
}
} else if (!dOrF) {
logInfo(path + „keine gültige Datei“);
return false;
}
return true;
}
/****
* Dateialgorithmus kopieren
*
* @param path1
*Ursprünglicher Pfad
* @param path2
* Zielpfad
* @param reCount
*Anzahl der Wiederholungen
* @param isCover
* Ob die Kopie überschrieben werden soll
* @param-Typen
* Unabhängig davon, ob der Zielpfad, den Sie schreiben, eine Datei oder ein Ordner ist, müssen Sie ihn nicht schreiben. Der Standardwert ist eine Datei.
* @zurückkehren
*/
public boolean copeFileCore(Path path1, Path path2, int reCount,
boolesche isCover-, PathType...-Typen) {
//Wenn die Originaldatei nicht existiert, wird direkt eine Ausnahme ausgelöst
if (!initCheck() || !initCheck2s(path1, false))
return false;
PathType type = PathType.FILES;
if (types != null &&types.length > 0) {
Typ = Typen[0];
// Wenn das Ziel ein Ordner ist und die angegebene Kopie in einen Ordner erfolgt
if (type.equals(PathType.DIRS)) {
path2 = Paths.get(path2.toString(), path1.getFileName()
.toString());
}
}
// Wenn die Zieldatei bereits vorhanden ist, ermitteln Sie, ob sie identisch ist. Wenn sie identisch ist, muss sie nicht kopiert werden.
if (Files.exists(path2)) {
if (Files.isDirectory(path2) && PathType.FILES.equals(type)) {
logInfo(path2 + „existiert bereits, es ist ein Ordner, keine Datei“);
return false;
}
if (isSameFile(path1, path2, useMd5))
return true;
}
// Wenn die Zieldatei nicht existiert
anders {
Pfad parPath = path2.getParent();
// Wenn der übergeordnete Ordner der Zieldatei nicht existiert, versuchen Sie, ihn zu erstellen
if (!Files.exists(parPath))
for (int i = 1; i < reCount; i++) {
versuchen {
Files.createDirectories(parPath);
brechen;
} Catch (Ausnahme e) {
if (i == reCount) {
logInfo(e);
return false;
}
}
}
}
for (int i = 1; i <= reCount; i++) {
versuchen {
if(isCover)
Files.copy(path1, path2,
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.COPY_ATTRIBUTES);
anders
Files.copy(path1, path2, StandardCopyOption.COPY_ATTRIBUTES);
// Synchronisiere die letzte Änderungszeit
synLastFileTime(path1, path2);
brechen;
} Catch (IOException e) {
// Wenn die Kopie nicht innerhalb der angegebenen Zeit abgeschlossen werden kann, wird sie in den Ausnahmeinformationen entscheidend erfasst.
if (i == reCount) {
logInfo(e);
return false;
}
}
}
return true;
}
public void copedir() {
if (!initCheck() || !initCheck2s(srcPath, true))
zurückkehren;
copDir(this.srcPath.toString(), this.tarPath.toString());
}
/***
* Ordnerschutzschicht kopieren
*
* @param path1
* @param path2
*/
public void copedir(String path1, final String path2) {
if (!initCheck() || !initCheck2s(srcPath, true))
zurückkehren;
Pfad p1 = Paths.get(path1);
endgültiger Pfad tarPath = Paths.get(path2);
if (!isCopeAllPath)
subNameNum = srcPath.getNameCount() - 1;
versuchen {
Files.walkFileTree(p1, new FileVisitor<Path>() {
Pfad p2 = null;
Stack<Path> dirStack = new Stack<Path>();
@Override
public FileVisitResult preVisitDirectory(Pfad dir,
BasicFileAttributes attrs) wirft IOException {
// Wenn Sie nicht den vollständigen Pfad kopieren, verwenden Sie ihn als Datensatzspeicherort des Namensknotens dieses Ordners.
// if (!copeAllPath)
/****
* Wenn es sich um denselben Ordner handelt, überspringen Sie das Kopieren.
*/
if (isSamePath(dir, tarPath)) {
System.out.println("Es ist das Gleiche, überspringen!!!!!!!!!!!!!!!!!!!");
return FileVisitResult.SKIP_SUBTREE;
}
p2 = replacePath(dir, path2, subNameNum);
if (dir.toFile().length() == 0 && !Files.exists(p2))
Files.createDirectories(p2);
dirStack.push(p2);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Pfaddatei,
BasicFileAttributes attrs) wirft IOException {
Path toFilePath = Paths.get(dirStack.peek().toString(),
file.getFileName().toString());
copFileCore(file, toFilePath, 3, true);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Pfaddatei,
IOException exc) wirft IOException {
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Pfad dir,
IOException exc) wirft IOException {
if (!dirStack.isEmpty())
dirStack.pop();
return FileVisitResult.CONTINUE;
}
});
} Catch (IOException e) {
logInfo(e);
}
}
/***
* Pfad ersetzen
*
* @param path1
* @param path2
* @zurückkehren
*/
privater Pfad replacePath(Pfad path1, String path2, int nameCountNum) {
if (path1.getNameCount() == 0 && path1.equals(path1.getRoot()))
return Paths.get(path2);
return Paths.get(path2,
path1.subpath(nameCountNum, path1.getNameCount()).toString());
}
/***
* Entweder ist die Adresse genau dieselbe, oder die übergeordnete Klasse der Originaldatei ist dieselbe wie die des Ziels, da das Programm das Kopieren in die übergeordnete Klasse unterstützt
*
* @param path1
* @param path2
* @zurückkehren
*/
privater boolescher Wert isSamePath(Pfad Pfad1, Pfad Pfad2) {
if (path1.equals(path2))
return true;
return false;
}
/***
* Dateiänderungszeit synchronisieren
*
* @param path1
* @param path2
* @zurückkehren
*/
public boolean synLastFileTime(Path path1, Path path2) {
FileTime srcPathTime;
versuchen {
srcPathTime = Files.getLastModifiedTime(path1);
Files.setLastModifiedTime(path2, srcPathTime);
return srcPathTime.equals(Files.getLastModifiedTime(path2));
} Catch (IOException e) {
logInfo(e);
return false;
}
}
/***
* Stellen Sie fest, ob zwei Dateien gleich sind
*
* @param path1
* @param path2
* @zurückkehren
*/
public boolean isSameFile(Path path1, Path path2, boolean useMd5) {
versuchen {
// Solange die Längen der beiden Dateien inkonsistent sind, handelt es sich definitiv nicht um dieselbe Datei.
if (Files.size(path1) != Files.size(path2))
return false;
// Wenn die letzte Änderungszeit unterschiedlich ist, verwenden Sie direkt die MD5-Überprüfung.
else if (!Files.getLastModifiedTime(path1).equals(
Files.getLastModifiedTime(path2))
||. useMd5)
return MD5Util.getFileMD5String(path1.toFile()).equals(
MD5Util.getFileMD5String(path2.toFile()));
return true;
} Catch (Ausnahme e) {
logInfo(e);
return false;
}
}
/***
* Zur Ausnahmebehandlung
*/
private void logInfo(Ausnahme e) {
if (this.logger != null)
logger.error(e.getMessage());
sonst wenn (e != null)
System.out.println("Exception:" + e.getMessage());
}
private void logInfo(String errorMessage) {
if (this.logger != null)
logger.error(errorMessage);
anders
System.out.println("Exception:" + errorMessage);
}
public static void main(String[] args) {
// new MyFiles2("e:/t/1.txt", "e:/3/33").copeFileCore();
MyFiles2 my = new MyFiles2("e:/ttt/tt/t/1.txt", "e:/3/33.txt");
my.copeFileCore(PathType.DIRS);
}
}
Kopieren Sie den Codecode wie folgt:
öffentliche Aufzählung PathType {
DATEIEN, VERZEICHNISE;
}
Kopieren Sie den Codecode wie folgt:
import java.io.Closeable;
öffentliche Klasse CloseIoUtil {
/***
* Schließen Sie den IO-Stream
*
* @param cls
*/
public static void closeAll(Closeable... cls) {
if (cls != null) {
for (Verschließbare cl : cls) {
versuchen {
if (cl != null)
cl.close();
} Catch (Ausnahme e) {
} Endlich {
cl = null;
}
}
}
}
}
Kopieren Sie den Codecode wie folgt:
import java.io.BufferedInputStream;
java.io.File importieren;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
öffentliche Klasse MD5Util {
protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
protected static MessageDigest messagedigest = null;
statisch {
versuchen {
messagedigest = MessageDigest.getInstance("MD5");
} Catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
öffentlicher statischer String getFileMD5String(File file) löst eine IOException {
/***
*MappedByteBuffer ist die API von NIO. Bei der Verwendung dieser API tritt ein Fehler auf.
* Bei Verwendung der FileChannel.map-Methode hat MappedByteBuffer bereits ein Handle im System belegt.
* Dieses Handle kann nicht mit der FileChannel.close-Methode freigegeben werden.,
* Und stellt FileChannel eine Methode bereit, die der Aufhebung der Zuordnung ähnelt, sodass es Situationen gibt, in denen die Datei nicht gelöscht werden kann?
*/
// FileInputStream in = new FileInputStream(file);
// FileChannel ch = in.getChannel();
// MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY,
// 0,
// file.length());
InputStream fis = null;
BufferedInputStream bis = null;
fis = new FileInputStream(file);
bis = new BufferedInputStream(fis);
byte[] buffer = neues byte[2048];
int numRead = 0;
while ((numRead = bis.read(buffer)) > 0) {
messagedigest.update(buffer, 0, numRead);
}
CloseIoUtil.closeAll(bis,fis);
return bufferToHex(messagedigest.digest());
}
öffentlicher statischer String getMD5String(String s) {
return getMD5String(s.getBytes());
}
öffentlicher statischer String getMD5String(byte[] bytes) {
messagedigest.update(bytes);
return bufferToHex(messagedigest.digest());
}
privater statischer String bufferToHex(byte bytes[]) {
return bufferToHex(bytes, 0, bytes.length);
}
privater statischer String bufferToHex(byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n;
for (int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0) >> 4];
char c1 = hexDigits[bt & 0xf];
stringbuffer.append(c0);
stringbuffer.append(c1);
}
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
public static void main(String[] args) löst eine IOException {
File big = new File("e:/sss.txt");
String md5 = getFileMD5String(big);
//
// long end = System.currentTimeMillis();
// System.out.println("md5:" + md5);
// System.out.println("time:" + ((end - begin) / 1000) + "s");
System.out.println(md5);
}
}
Kopieren Sie den Codecode wie folgt:
import java.io.BufferedInputStream;
java.io.File importieren;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
öffentliche Klasse MD5Util {
protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
protected static MessageDigest messagedigest = null;
statisch {
versuchen {
messagedigest = MessageDigest.getInstance("MD5");
} Catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
öffentlicher statischer String getFileMD5String(File file) löst eine IOException {
/***
*MappedByteBuffer ist die API von NIO. Bei der Verwendung dieser API tritt ein Fehler auf.
* Bei Verwendung der FileChannel.map-Methode hat MappedByteBuffer bereits ein Handle im System belegt.
* Dieses Handle kann nicht mit der FileChannel.close-Methode freigegeben werden.,
* Und stellt FileChannel eine Methode bereit, die der Aufhebung der Zuordnung ähnelt, sodass es Situationen gibt, in denen die Datei nicht gelöscht werden kann?
*/
// FileInputStream in = new FileInputStream(file);
// FileChannel ch = in.getChannel();
// MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY,
// 0,
// file.length());
InputStream fis = null;
BufferedInputStream bis = null;
fis = new FileInputStream(file);
bis = new BufferedInputStream(fis);
byte[] buffer = neues byte[2048];
int numRead = 0;
while ((numRead = bis.read(buffer)) > 0) {
messagedigest.update(buffer, 0, numRead);
}
CloseIoUtil.closeAll(bis,fis);
return bufferToHex(messagedigest.digest());
}
öffentlicher statischer String getMD5String(String s) {
return getMD5String(s.getBytes());
}
öffentlicher statischer String getMD5String(byte[] bytes) {
messagedigest.update(bytes);
return bufferToHex(messagedigest.digest());
}
privater statischer String bufferToHex(byte bytes[]) {
return bufferToHex(bytes, 0, bytes.length);
}
privater statischer String bufferToHex(byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n;
for (int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0) >> 4];
char c1 = hexDigits[bt & 0xf];
stringbuffer.append(c0);
stringbuffer.append(c1);
}
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
public static void main(String[] args) löst eine IOException {
File big = new File("e:/sss.txt");
String md5 = getFileMD5String(big);
//
// long end = System.currentTimeMillis();
// System.out.println("md5:" + md5);
// System.out.println("time:" + ((end - begin) / 1000) + "s");
System.out.println(md5);
}
}