Android InputStream Copy copy(InputStream pSourceStream, OutputStream pTargetStream, boolean closeSource)

Description

destination is not closed on exit of method !

License

Apache License

Parameter

Parameter	Description
pSourceStream	a parameter
pTargetStream	a parameter
closeSource	define if the source id closed after copying

Exception

Parameter	Description
IOException	an exception

Declaration

public static synchronized void copy(InputStream pSourceStream,
        OutputStream pTargetStream, boolean closeSource)
        throws IOException 

Method Source Code

/**/*from w ww  .j  a va  2s.  com*/
 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(InputStream input, OutputStream output)
2. copy(InputStream input, Writer output)
3. copy(InputStream input, Writer output, String encoding)
4. copy(InputStream inputStream, OutputStream outputStream)
5. copy(InputStream pSourceStream, OutputStream pTargetStream)
6. copyContents(InputStream in, OutputStream out)
7. copyFile(InputStream from, String target)
8. copyFile(InputStream in, File out)
9. copyFile(InputStream in, OutputStream out)