Description
Copies a directory.
License
Apache License
Parameter
| Parameter | Description |
|---|
| source | the directory to copy |
| target | the target directory |
Exception
| Parameter | Description |
|---|
| IOException | if a problem occurred during the copy |
Declaration
public static void copyDirectory(File source, File target) throws IOException
Method Source Code
//package com.java2s;
/**/* w ww. jav a 2s .com*/
* Copyright 2013-2015 Linagora, Universit? Joseph Fourier, Floralis
*
* The present code is developed in the scope of the joint LINAGORA -
* Universit? Joseph Fourier - Floralis research program and is designated
* as a "Result" pursuant to the terms and conditions of the LINAGORA
* - Universit? Joseph Fourier - Floralis research program. Each copyright
* holder of Results enumerated here above fully & independently holds complete
* ownership of the complete Intellectual Property rights applicable to the whole
* of said Results, and may freely exploit it in any manner which does not infringe
* the moral rights of the other copyright holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
public class Main {
/**
* Copies a directory.
* <p>
* This method copies the content of the source directory
* into the a target directory. This latter is created if necessary.
* </p>
*
* @param source the directory to copy
* @param target the target directory
* @throws IOException if a problem occurred during the copy
*/
public static void copyDirectory(File source, File target) throws IOException {
if (!target.exists() && !target.mkdirs())
throw new IOException("The directory " + target + " could not be created.");
for (File sourceFile : listAllFiles(source)) {
String path = computeFileRelativeLocation(source, sourceFile);
File targetFile = new File(target, path);
if (!targetFile.getParentFile().exists() && !targetFile.getParentFile().mkdirs())
throw new IOException("The directory " + targetFile.getParentFile() + " could not be created.");
copyStream(sourceFile, targetFile);
}
}
/**
* Finds all the files (direct and indirect) from a directory.
* <p>
* This method skips hidden files and files whose name starts
* with a dot.
* </p>
*
* @param directory an existing directory
* @return a non-null list of files
*/
public static List<File> listAllFiles(File directory) {
if (!directory.exists() || !directory.isDirectory())
throw new IllegalArgumentException(
directory.getAbsolutePath() + " does not exist or is not a directory.");
List<File> result = new ArrayList<File>();
List<File> directoriesToInspect = new ArrayList<File>();
directoriesToInspect.add(directory);
while (!directoriesToInspect.isEmpty()) {
File[] subFiles = directoriesToInspect.remove(0).listFiles();
if (subFiles == null)
continue;
for (File subFile : subFiles) {
if (subFile.isHidden() || subFile.getName().startsWith("."))
continue;
if (subFile.isFile())
result.add(subFile);
else
directoriesToInspect.add(subFile);
}
}
return result;
}
/**
* Computes the relative location of a file with respect to a root directory.
* @param rootDirectory a directory
* @param subFile a file contained (directly or indirectly) in the directory
* @return a non-null string
*/
public static String computeFileRelativeLocation(File rootDirectory, File subFile) {
String rootPath = rootDirectory.getAbsolutePath();
String subPath = subFile.getAbsolutePath();
if (!subPath.startsWith(rootPath))
throw new IllegalArgumentException("The sub-file must be contained in the directory.");
if (rootDirectory.equals(subFile))
throw new IllegalArgumentException("The sub-file must be different than the directory.");
return subPath.substring(rootPath.length() + 1).replace('\\', '/');
}
/**
* Copies the content from in into os.
* <p>
* Neither <i>in</i> nor <i>os</i> are closed by this method.<br />
* They must be explicitly closed after this method is called.
* </p>
*
* @param in an input stream (not null)
* @param os an output stream (not null)
* @throws IOException if an error occurred
*/
public static void copyStream(InputStream in, OutputStream os) throws IOException {
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
os.write(buf, 0, len);
}
}
/**
* Copies the content from in into outputFile.
* <p>
* <i>in</i> is not closed by this method.<br />
* It must be explicitly closed after this method is called.
* </p>
*
* @param in an input stream (not null)
* @param outputFile will be created if it does not exist
* @throws IOException if the file could not be created
*/
public static void copyStream(InputStream in, File outputFile) throws IOException {
OutputStream os = new FileOutputStream(outputFile);
try {
copyStream(in, os);
} finally {
os.close();
}
}
/**
* Copies the content from inputFile into outputFile.
*
* @param inputFile an input file (must be a file and exist)
* @param outputFile will be created if it does not exist
* @throws IOException if something went wrong
*/
public static void copyStream(File inputFile, File outputFile) throws IOException {
InputStream is = new FileInputStream(inputFile);
try {
copyStream(is, outputFile);
} finally {
is.close();
}
}
/**
* Copies the content from inputFile into an output stream.
*
* @param inputFile an input file (must be a file and exist)
* @param os the output stream
* @throws IOException if something went wrong
*/
public static void copyStream(File inputFile, OutputStream os) throws IOException {
InputStream is = new FileInputStream(inputFile);
try {
copyStream(is, os);
} finally {
is.close();
}
}
}
Related
- copyDirectory(File source, File destination)
- copyDirectory(File source, File destination, boolean overwrite)
- copyDirectory(File source, File destination, String endWith)
- copyDirectory(File source, File target)
- copyDirectory(File source, File target)
- copyDirectory(File source, File target)
- copyDirectory(File source, File target)
- copyDirectory(File source, File target)
- copyDirectory(File sourceDir, File destDir)