Android File Copy copy(String pSourceFile, String pTargetFile)

Here you can find the source of copy(String pSourceFile, String pTargetFile)

Description

copy

License

Apache License

Parameter

Parameter Description
pSourceFile a parameter
pTargetFile a parameter

Exception

Parameter Description
IOException an exception

Declaration

public static synchronized void copy(String pSourceFile,
        String pTargetFile) throws IOException 

Method Source Code

/**//from  w w w . j  a  va 2  s .co m
 Copyright 2014 Jens Glufke

 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.
 * -----------------------------------------------------------------------<br>
 * 
 * class that can be used to operations on files like copy, deleteDir etc 
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

public class Main{
    /**
     * 
     * @param pSourceFile
     * @param pTargetFile
     * @throws IOException
     */
    public static synchronized void copy(File pSourceFile, File pTargetFile)
            throws IOException {

        if (!pSourceFile.getCanonicalPath().equals(
                pTargetFile.getCanonicalPath())) {

            pTargetFile.getParentFile().mkdirs();

            FileInputStream lFIS = new FileInputStream(pSourceFile);
            FileOutputStream lFOS = new FileOutputStream(
                    pTargetFile.getCanonicalPath());
            copy(lFIS, lFOS);
            lFOS.close();
        }
    }
    /**
     * destination is not closed on exit of method !
     * @param pSourceStream
     * @param pTargetStream
     * @throws IOException
     */
    public static synchronized void copy(InputStream pSourceStream,
            OutputStream pTargetStream) throws IOException {
        copy(pSourceStream, pTargetStream, true);
    }
    /**
     * destination is not closed on exit of method !
     * @param pSourceStream
     * @param pTargetStream
     * @param closeSource define if the source id closed after copying
     * @throws IOException
     */
    public static synchronized void copy(InputStream pSourceStream,
            OutputStream pTargetStream, boolean closeSource)
            throws IOException {

        final int buffSize = 1024;
        final byte[] lBuf = new byte[buffSize];

        int lBytesRead = 0;
        while ((lBytesRead = pSourceStream.read(lBuf, 0, buffSize)) != -1) {
            pTargetStream.write(lBuf, 0, lBytesRead);
        }
        if (closeSource) {
            pSourceStream.close();
        }
    }
    /**
     * 
     * @param pSourceFile
     * @param pTargetFile
     * @throws IOException
     */
    public static synchronized void copy(String pSourceFile,
            String pTargetFile) throws IOException {

        copy(new File(pSourceFile), new File(pTargetFile));
    }
    /**
     * 
     * @param pFile
     * @return
     */
    public static String getCanonicalPath(File pFile) {

        String lReturnPath = pFile.getAbsolutePath();
        lReturnPath = lReturnPath.replaceAll("\\\\", "/");

        final String regExp1 = "()[^/]+/(\\.\\.)";
        final Pattern pattern1 = Pattern.compile(regExp1);
        final String regExp2 = "([^/]+/)(\\.)";
        final Pattern pattern2 = Pattern.compile(regExp2);
        final String regExp3 = "(/)(/)";
        final Pattern pattern3 = Pattern.compile(regExp3);

        for (Pattern lPattern : new Pattern[] { pattern1, pattern2,
                pattern3 }) {
            Matcher lMatcher = lPattern.matcher(lReturnPath);
            while (lMatcher.find()) {
                lReturnPath = lMatcher.replaceFirst(lMatcher.group(1));
                lMatcher = lPattern.matcher(lReturnPath);
            }
        }
        if (lReturnPath.endsWith("/")) {
            lReturnPath = lReturnPath
                    .substring(0, lReturnPath.length() - 1);
        }
        return lReturnPath;
    }
    /**
     * 
     * find a file in pDir and its sub directories that matches pFilter
     * @param pFoundFiles
     * @param pDir
     * @param pFilter
     * @return
     *
     */
    public static Vector<File> find(Vector<File> pFoundFiles, File pDir,
            FileFilter pFilter) {
        if (pDir.isDirectory()) {
            File[] lFoundFiles = pDir.listFiles(pFilter);
            if (lFoundFiles != null && lFoundFiles.length > 0) {
                pFoundFiles.addAll(Arrays.asList(lFoundFiles));
            }
            for (File lFile : pDir.listFiles()) {
                find(pFoundFiles, lFile, pFilter);
            }
        }
        return pFoundFiles;
    }
    /**
     * find all files in pDirectory and its sub directories whose absolute path
     * matches pRegex
     * @param pDirectory
     * @param pRegex
     * @return
     */
    public static synchronized Vector<File> find(File pDirectory,
            String pRegex) {
        Vector<File> lReturn = new Vector<File>();
        lReturn = find(lReturn, pDirectory, new RegExpFileFilter(pRegex));
        return lReturn;
    }
}

Related

  1. copy(File sourceFile, File targetFile)
  2. copy(File sourceFile, File targetFile, boolean overwrite)
  3. copy(File sourceFile, String destinction)
  4. copy(File src, File dest)
  5. copy(String input, String output)
  6. copy(String source, String destinction)
  7. copy(String srcFileName, String destFileName)
  8. copyBundleFile(IPath projectRelativePath, String outputPath)
  9. copyFile(File fin, File fout)