Ce programme a été créé uniquement pour rendre la copie de fichiers (dossiers) plus pratique.
1. Il n'est pas nécessaire de créer un nouveau dossier, c'est aussi simple que de copier et coller dans Windows.
2. Il existe un mécanisme simple de reconnexion en cas d'erreur
3. Pas besoin de dupliquer des copies, copiez les fichiers de manière différentielle.
4. Lors de la copie d'un dossier, vous n'avez pas besoin de copier le chemin complet, concentrez-vous simplement sur le dossier qui doit être copié.
5. Le programme effectue des vérifications simples et nécessaires et l'efficacité n'est pas faible.
6. La nouvelle API de nio2 de 7 est utilisée.
Copiez le code comme suit :
importer java.io.IOException ;
importer java.nio.file.FileVisitResult ;
importer java.nio.file.FileVisitor ;
importer java.nio.file.Files ;
importer java.nio.file.Path ;
importer java.nio.file.Paths ;
importer java.nio.file.StandardCopyOption ;
importer java.nio.file.attribute.BasicFileAttributes ;
importer java.nio.file.attribute.FileTime ;
importer java.util.Stack ;
importer org.apache.log4j.Logger ;
importer com.xyq.myfile.cope.entity.PathType ;
importer com.xyq.util.MD5Util ;
/***
* Algorithme de copie basé sur jdk7
*
* @auteur xyq
*
*/
classe publique MesFichiers2 {
chaîne privée src ;
tar de chaîne privée ;
Chemin privé srcPath ;
chemin privé tarPath ;
private int reCount = 3 ;
booléen privé isCover = false ;
privé booléen useMd5 = false ;
private int sousNomNum = 0 ;
// objet log4j
enregistreur privé Logger ;
// En mode dossier -> dossier, s'il faut copier le chemin complet, la valeur par défaut est de ne pas copier
booléen privé isCopeAllPath = false ;
public MyFiles2 (String src, String tar) {
this.src = src;
this.tar = tar;
this.srcPath = Chemins.get(src);
this.tarPath = Paths.get(tar);
}
public MesFichiers2() {
}
chaîne publique getSrc() {
retourner src ;
}
public void setSrc (Chaîne src) {
this.src = src;
this.srcPath = Chemins.get(src);
}
chaîne publique getTar() {
retourner le goudron ;
}
public void setTar(String tar) {
this.tar = tar;
this.tarPath = Paths.get(tar);
}
public int getReCount() {
retourner reCount ;
}
public void setReCount(int reCount) {
this.reCount = reCount;
}
public booléen isCover() {
retourner isCover ;
}
public void setCover(booléen isCover) {
this.isCover = isCover;
}
Enregistreur public getLogger() {
enregistreur de retour ;
}
public void setLogger (enregistreur de données) {
this.logger = enregistreur ;
}
public booléen isUseMd5() {
retourner useMd5 ;
}
public void setUseMd5 (booléen useMd5) {
this.useMd5 = useMd5;
}
public booléen isCopeAllPath() {
retourner isCopeAllPath ;
}
public void setCopeAllPath(boolean isCopeAllPath) {
this.isCopeAllPath = isCopeAllPath ;
}
public booléen copeFileCore (PathType... types) {
if (initCheck() && initCheck2s(this.srcPath, false))
return copeFileCore(this.srcPath, this.tarPath, reCount, isCover,
types);
renvoie faux ;
}
initCheck booléen privé() {
si (this.srcPath == null) {
logInfo("Le chemin d'origine n'est pas défini, le programme ne peut pas être démarré ~~");
renvoie faux ;
} sinon if (this.tarPath == null) {
logInfo("Le chemin cible n'est pas défini, le programme ne peut pas être démarré ~~");
renvoie faux ;
} sinon si (!Files.exists(srcPath)) {
logInfo("Le chemin d'origine n'existe pas, le programme ne peut pas être démarré~~");
renvoie faux ;
} sinon if (!Files.exists(tarPath.getRoot())) {
logInfo("La lettre de lecteur racine du chemin cible n'existe pas et le programme ne peut pas être démarré ~~");
renvoie faux ;
}
renvoie vrai ;
}
private boolean initCheck2s (Chemin d'accès, booléen dOrF) {
si (!Files.isDirectory(chemin)) {
si (dOrF) {
logInfo(chemin + "pas un dossier valide");
renvoie faux ;
}
} sinon si (!dOrF) {
logInfo(path + "pas un fichier valide");
renvoie faux ;
}
renvoie vrai ;
}
/****
* Algorithme de copie de fichier
*
* @param chemin1
*Chemin d'origine
* @param chemin2
* chemin cible
* @param reCount
*Nombre de répétitions
* @param isCover
* S'il faut écraser la copie
* Types @param
* Que le chemin cible que vous écrivez soit un fichier ou un dossier, vous n'avez pas besoin de l'écrire. La valeur par défaut est un fichier.
* @retour
*/
public booléen copeFileCore (Chemin chemin1, Chemin chemin2, int reCount,
booléen isCover, PathType... types) {
//Si le fichier d'origine n'existe pas, lancez directement une exception
si (!initCheck() || !initCheck2s(path1, false))
renvoie faux ;
Type de chemin = PathType.FILES ;
if (types != null && types.length > 0) {
type = types[0];
// Si la cible est un dossier et que la copie spécifiée est dans un dossier
if (type.equals(PathType.DIRS)) {
chemin2 = Chemins.get(chemin2.toString(), chemin1.getFileName()
.toString());
}
}
// Si le fichier cible existe déjà, déterminez s'il est identique. S'il est identique, il n'est pas nécessaire de le copier.
if (Files.exists(path2)) {
if (Files.isDirectory(path2) && PathType.FILES.equals(type)) {
logInfo(path2 + "existe déjà, c'est un dossier pas un fichier");
renvoie faux ;
}
if (isSameFile(path1, path2, useMd5))
renvoie vrai ;
}
// Lorsque le fichier cible n'existe pas
autre {
Chemin parPath = path2.getParent();
// Si le dossier parent du fichier cible n'existe pas, essayez de le créer
si (!Files.exists(parPath))
pour (int je = 1; je < reCount; i++) {
essayer {
Files.createDirectories(parPath);
casser;
} attraper (Exception e) {
si (i == reCount) {
logInfo(e);
renvoie faux ;
}
}
}
}
pour (int i = 1; i <= reCount; i++) {
essayer {
si (estCover)
Fichiers.copie(chemin1, chemin2,
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.COPY_ATTRIBUTES);
autre
Files.copy(chemin1, chemin2, StandardCopyOption.COPY_ATTRIBUTES);
// Synchronise l'heure de la dernière modification
synLastFileTime(chemin1, chemin2);
casser;
} catch (IOException e) {
// Si la copie ne peut pas être terminée dans le délai spécifié, elle sera alors enregistrée de manière décisive dans les informations d'exception.
si (i == reCount) {
logInfo(e);
renvoie faux ;
}
}
}
renvoie vrai ;
}
public void copeDir() {
si (!initCheck() || !initCheck2s(srcPath, true))
retour;
copeDir(this.srcPath.toString(), this.tarPath.toString());
}
/***
* Copier la couche de protection du dossier
*
* @param chemin1
* @param chemin2
*/
public void copeDir (String path1, final String path2) {
si (!initCheck() || !initCheck2s(srcPath, true))
retour;
Chemin p1 = Chemins.get(chemin1);
Chemin final tarPath = Paths.get(path2);
si (!isCopeAllPath)
subNameNum = srcPath.getNameCount() - 1;
essayer {
Files.walkFileTree(p1, nouveau FileVisitor<Path>() {
Chemin p2 = nul ;
Stack<Path> dirStack = new Stack<Path>();
@Outrepasser
public FileVisitResult preVisitDirectory(Chemin d'accès,
BasicFileAttributes attrs) lance IOException {
// Lorsque vous ne copiez pas le chemin complet, utilisez-le comme emplacement d'enregistrement du nœud de nom de ce dossier.
// si (!copeAllPath)
/****
* S'il s'agit du même dossier, ignorez la copie.
*/
if (isSamePath(dir, tarPath)) {
System.out.println("C'est pareil, sautez !!!!!!!!!!!!!!!!");
renvoyer FileVisitResult.SKIP_SUBTREE ;
}
p2 = replacePath(dir, path2, subNameNum);
if (dir.toFile().length() == 0 && !Files.exists(p2))
Fichiers.createDirectories(p2);
dirStack.push(p2);
retourner FileVisitResult.CONTINUE ;
}
@Outrepasser
public FileVisitResult visitFile(Chemin du fichier,
BasicFileAttributes attrs) lance IOException {
Chemin versFilePath = Paths.get(dirStack.peek().toString(),
file.getFileName().toString());
copeFileCore(fichier, toFilePath, 3, true);
retourner FileVisitResult.CONTINUE ;
}
@Outrepasser
public FileVisitResult visitFileFailed(Chemin du fichier,
IOException exc) lance IOException {
retourner FileVisitResult.CONTINUE ;
}
@Outrepasser
public FileVisitResult postVisitDirectory(Chemin d'accès,
IOException exc) lance IOException {
si (!dirStack.isEmpty())
dirStack.pop();
retourner FileVisitResult.CONTINUE ;
}
});
} catch (IOException e) {
logInfo(e);
}
}
/***
* Remplacer le chemin
*
* @param chemin1
* @param chemin2
* @retour
*/
Chemin privé replacePath (Chemin chemin1, Chaîne chemin2, int nameCountNum) {
if (path1.getNameCount() == 0 && path1.equals(path1.getRoot()))
return Paths.get(path2);
return Paths.get(chemin2,
path1.subpath(nameCountNum, path1.getNameCount()).toString());
}
/***
* Soit l'adresse est exactement la même, soit la classe parent du fichier d'origine est la même que la cible, car le programme prend en charge la copie vers la classe parent.
*
* @param chemin1
* @param chemin2
* @retour
*/
booléen privé isSamePath (Chemin chemin1, Chemin chemin2) {
si (chemin1.equals(chemin2))
renvoie vrai ;
renvoie faux ;
}
/***
* Synchroniser l'heure de modification du fichier
*
* @param chemin1
* @param chemin2
* @retour
*/
public booléen synLastFileTime (Chemin chemin1, Chemin chemin2) {
FileTime srcPathTime ;
essayer {
srcPathTime = Files.getLastModifiedTime(path1);
Files.setLastModifiedTime(path2, srcPathTime);
return srcPathTime.equals(Files.getLastModifiedTime(path2));
} catch (IOException e) {
logInfo(e);
renvoie faux ;
}
}
/***
* Déterminer si deux fichiers sont identiques
*
* @param chemin1
* @param chemin2
* @retour
*/
public boolean isSameFile (Chemin chemin1, Chemin chemin2, booléen useMd5) {
essayer {
// Tant que les longueurs des deux fichiers sont incohérentes, il ne s'agit certainement pas du même fichier.
if (Files.size(path1) != Files.size(path2))
renvoie faux ;
// Si l'heure de la dernière modification est différente, utilisez directement la vérification MD5.
sinon si (!Files.getLastModifiedTime(path1).equals(
Fichiers.getLastModifiedTime(path2))
|| utiliserMd5)
return MD5Util.getFileMD5String(path1.toFile()).equals(
MD5Util.getFileMD5String(path2.toFile()));
renvoie vrai ;
} attraper (Exception e) {
logInfo(e);
renvoie faux ;
}
}
/***
* Pour la gestion des exceptions
*/
private void logInfo (Exception e) {
si (this.logger != null)
logger.error(e.getMessage());
sinon si (e != null)
System.out.println("Exception :" + e.getMessage());
}
private void logInfo (String errorMessage) {
si (this.logger != null)
logger.error (message d'erreur);
autre
System.out.println("Exception :" + message d'erreur);
}
public static void main (String[] arguments) {
// new MyFiles2("e:/t/1.txt", "e:/3/33").copeFileCore();
MyFiles2 my = new MyFiles2("e:/ttt/tt/t/1.txt", "e:/3/33.txt");
mon.copeFileCore(PathType.DIRS);
}
}
Copiez le code comme suit :
énumération publique PathType {
FICHIERS, RÉPERTOIRES ;
}
Copiez le code comme suit :
importer java.io.Closeable ;
classe publique CloseIoUtil {
/***
* Fermez le flux IO
*
* @param cls
*/
public static void closeAll (Fermable... cls) {
si (cls != nul) {
pour (Fermable cl : cls) {
essayer {
si (cl != nul)
cl.close();
} attraper (Exception e) {
} enfin {
cl = nul ;
}
}
}
}
}
Copiez le code comme suit :
importer java.io.BufferedInputStream ;
importer java.io.File ;
importer java.io.FileInputStream ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer java.security.MessageDigest ;
importer java.security.NoSuchAlgorithmException ;
classe publique MD5Util {
char statique protégé hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' } ;
MessageDigest statique protégé messagedigest = null;
statique {
essayer {
messagedigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
La chaîne statique publique getFileMD5String (fichier fichier) lance IOException {
/***
*MappedByteBuffer est l'API de NIO. Il y aura un bug lors de l'utilisation de cette API.
* Lors de l'utilisation de la méthode FileChannel.map, MappedByteBuffer a déjà occupé un handle dans le système.
* Ce handle ne peut pas être libéré à l'aide de la méthode FileChannel.close.,
* Et FileChannel fournit-il une méthode similaire à unmap, il y aura donc des situations dans lesquelles le fichier ne pourra pas être supprimé.
*/
// FileInputStream dans = new FileInputStream(file);
// FileChannel ch = in.getChannel();
// MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY,
// 0,
// fichier.length());
InputStream fis = nul ;
BufferedInputStream bis = null ;
fis = nouveau FileInputStream(fichier);
bis = nouveau BufferedInputStream(fis);
octet[] tampon = nouvel octet[2048];
int numRead = 0;
while ((numRead = bis.read(buffer)) > 0) {
messagedigest.update(buffer, 0, numRead);
}
CloseIoUtil.closeAll(bis,fis);
return bufferToHex(messagedigest.digest());
}
chaîne statique publique getMD5String(String s) {
return getMD5String(s.getBytes());
}
chaîne statique publique getMD5String (octet [] octets) {
messagedigest.update(octets);
return bufferToHex(messagedigest.digest());
}
chaîne statique privée bufferToHex (octet octets []) {
return bufferToHex(bytes, 0, bytes.length);
}
chaîne statique privée bufferToHex (octet octets [], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n ;
pour (int l = m; l < k; l++) {
appendHexPair(octets[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair (octet 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) {
Chaîne s = getMD5String(mot de passe);
return s.equals(md5PwdStr);
}
public static void main (String[] args) lance IOException {
Fichier gros = nouveau Fichier("e:/sss.txt");
Chaîne md5 = getFileMD5String(big);
//
// extrémité longue = System.currentTimeMillis();
// System.out.println("md5:" + md5);
// System.out.println("time:" + ((fin - début) / 1000) + "s");
System.out.println(md5);
}
}
Copiez le code comme suit :
importer java.io.BufferedInputStream ;
importer java.io.File ;
importer java.io.FileInputStream ;
importer java.io.IOException ;
importer java.io.InputStream ;
importer java.security.MessageDigest ;
importer java.security.NoSuchAlgorithmException ;
classe publique MD5Util {
char statique protégé hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' } ;
MessageDigest statique protégé messagedigest = null;
statique {
essayer {
messagedigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
La chaîne statique publique getFileMD5String (fichier fichier) lance IOException {
/***
*MappedByteBuffer est l'API de NIO. Il y aura un bug lors de l'utilisation de cette API.
* Lors de l'utilisation de la méthode FileChannel.map, MappedByteBuffer a déjà occupé un handle dans le système.
* Ce handle ne peut pas être libéré à l'aide de la méthode FileChannel.close.,
* Et FileChannel fournit-il une méthode similaire à unmap, il y aura donc des situations dans lesquelles le fichier ne pourra pas être supprimé.
*/
// FileInputStream dans = new FileInputStream(file);
// FileChannel ch = in.getChannel();
// MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY,
// 0,
// fichier.length());
InputStream fis = nul ;
BufferedInputStream bis = null ;
fis = nouveau FileInputStream(fichier);
bis = nouveau BufferedInputStream(fis);
octet[] tampon = nouvel octet[2048];
int numRead = 0;
while ((numRead = bis.read(buffer)) > 0) {
messagedigest.update(buffer, 0, numRead);
}
CloseIoUtil.closeAll(bis,fis);
return bufferToHex(messagedigest.digest());
}
chaîne statique publique getMD5String(String s) {
return getMD5String(s.getBytes());
}
chaîne statique publique getMD5String (octet [] octets) {
messagedigest.update(octets);
return bufferToHex(messagedigest.digest());
}
chaîne statique privée bufferToHex (octet octets []) {
return bufferToHex(bytes, 0, bytes.length);
}
chaîne statique privée bufferToHex (octet octets [], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n ;
pour (int l = m; l < k; l++) {
appendHexPair(octets[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair (octet 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) {
Chaîne s = getMD5String(mot de passe);
return s.equals(md5PwdStr);
}
public static void main (String[] args) lance IOException {
Fichier gros = nouveau Fichier("e:/sss.txt");
Chaîne md5 = getFileMD5String(big);
//
// extrémité longue = System.currentTimeMillis();
// System.out.println("md5:" + md5);
// System.out.println("time:" + ((fin - début) / 1000) + "s");
System.out.println(md5);
}
}