FileUtils.java Source code

Introduction

Here is the source code for FileUtils.java

Source

/* 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 
 * FileUtils is a collection of routines for common file system operations.
 * 
 * @author Dan Jemiolo (danj)
 * 
 */

public final class FileUtils {

    /**
     * 
     * The application's current working directory.
     * 
     */
    public static final File CURRENT_DIR = new File(".");

    /**
     * 
     * Copies the first file or directory to the second file or directory. <br>
     * <br>
     * If the first parameter is a file and the second is a file, then the method
     * copies the contents of the first file into the second. If the second file
     * does not exist, it is created. <br>
     * <br>
     * If the first parameter is a file and the second is a directory, the file is
     * copied to the directory, overwriting any existing copy. <br>
     * <br>
     * If the first parameter is a directory and the second is a directory, the
     * first is copied underneath the second. <br>
     * <br>
     * If the first parameter is a directory and the second is a file name or does
     * not exist, a directory with that name is created, and the contents of the
     * first directory are copied there.
     * 
     * @param source
     * @param destination
     * 
     * @throws IOException
     *           <ul>
     *           <li>If the source does not exist.</li>
     *           <li>If the user does not have permission to modify the
     *           destination.</li>
     *           <li>If the copy fails for some reason related to system I/O.</li>
     *           </ul>
     * 
     */
    public static void copy(File source, File destination) throws IOException {
        if (source == null)
            throw new NullPointerException("NullSource");

        if (destination == null)
            throw new NullPointerException("NullDestination");

        if (source.isDirectory())
            copyDirectory(source, destination);

        else
            copyFile(source, destination);
    }

    public static void copyDirectory(File source, File destination) throws IOException {
        copyDirectory(source, destination, null);
    }

    public static void copyDirectory(File source, File destination, FileFilter filter) throws IOException {
        File nextDirectory = new File(destination, source.getName());

        //
        // create the directory if necessary...
        //
        if (!nextDirectory.exists() && !nextDirectory.mkdirs()) {
            Object[] filler = { nextDirectory.getAbsolutePath() };
            String message = "DirCopyFailed";
            throw new IOException(message);
        }

        File[] files = source.listFiles();

        //
        // and then all the items below the directory...
        //
        for (int n = 0; n < files.length; ++n) {
            if (filter == null || filter.accept(files[n])) {
                if (files[n].isDirectory())
                    copyDirectory(files[n], nextDirectory, filter);

                else
                    copyFile(files[n], nextDirectory);
            }
        }
    }

    public static void copyFile(File source, File destination) throws IOException {
        //
        // if the destination is a dir, what we really want to do is create
        // a file with the same name in that dir
        //
        if (destination.isDirectory())
            destination = new File(destination, source.getName());

        FileInputStream input = new FileInputStream(source);
        copyFile(input, destination);
    }

    public static void copyFile(InputStream input, File destination) throws IOException {
        OutputStream output = null;

        output = new FileOutputStream(destination);

        byte[] buffer = new byte[1024];

        int bytesRead = input.read(buffer);

        while (bytesRead >= 0) {
            output.write(buffer, 0, bytesRead);
            bytesRead = input.read(buffer);
        }

        input.close();

        output.close();
    }

}