Utility methods for handling files and directories : Directory « File Input Output « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » File Input Output » DirectoryScreenshots 
Utility methods for handling files and directories
      
//The contents of this file are subject to the Mozilla Public License Version 1.1
//(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.mozilla.org/MPL/
//
//Software distributed under the License is distributed on an "AS IS" basis,
//WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
//for the specific language governing rights and
//limitations under the License.
//
//The Original Code is "The Columba Project"
//
//The Initial Developers of the Original Code are Frederik Dietz and Timo Stich.
//Portions created by Frederik Dietz and Timo Stich are Copyright (C) 2003.
//
//All Rights Reserved.


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;
import java.util.logging.Logger;

/**
 * Utility methods for handling files and directories.
 */
public final class DiskIO {

  private static final Logger LOG = Logger.getLogger("org.columba.core.io");

  private static String resourceFolder = "";

  /**
   * Private constructor for utility class.
   */
  private DiskIO() {
    // don't instantiate this
  }

  /**
   * Ensures the existence of the directory specified by the parameter. If the
   * directory does not exist, an attempt is performed to create it including
   * all necessary parent directories that may be implied by the
   * specification. ### HELPME : against what should a relative pathname be
   * made absolute? ### ### We need to set the installation directory
   * somewhere! ####
   
   @param dir
   *            File specifying the intended directory name; if the specified
   *            name is a relative path, it is always made absolute against
   *            the program's <b>installationDirectory </b>.
   @return <b>true </b> if and only if the specified file exists and is a
   *         directory
   */
  public static boolean ensureDirectory(File dir) {
    if (dir == null) {
      throw new IllegalArgumentException("dir = null");
    }
    boolean success = true;
    if (!dir.isDirectory()) {
      success = !dir.isFile() && dir.mkdirs();

      if (success) {
        LOG.info("Created directory: " + dir.toString());
      else {
        LOG.severe("failed while trying to create directory: "
            + dir.toString());
      }
    }

    return success;
  }

  // ensureDirectory
  public static boolean ensureDirectory(String path) {
    return ensureDirectory(new File(path));
  }

  public static void saveStringInFile(File toFile, String insertString)
      throws IOException {
    BufferedWriter out;

    out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(
        toFile)"ISO-8859-1"));
    out.write(insertString);
    out.flush();
    out.close();
  }


  // saveStringInFile
  public static String readFileInString(File fromFilethrows IOException {
    StringBuffer strbuf = new StringBuffer((intfromFile.length());

    BufferedReader in = new BufferedReader(new InputStreamReader(
        new FileInputStream(fromFile)"ISO-8859-1"));
    String str;
    strbuf = new StringBuffer((intfromFile.length());

    while ((str = in.readLine()) != null) {
      strbuf.append(str + "\n");
    }

    in.close();

    return strbuf.toString();

    /*
     * int lineNumber = 0; byte[] buffer = new byte[1024]; int read;
     * StringBuffer out = new StringBuffer((int)fromFile.length());
     * FileInputStream in = new FileInputStream( fromFile );
     
     * read = in.read(buffer); while ( read == 1024 ) { out.append(new
     * String(buffer,"ISO-8859-1")); read = in.read(buffer); }
     
     * out.append(new String(buffer,0,read,"ISO-8859-1")); in.close();
     
     * return out.toString();
     */
  }

  // saveStringInFile

  /**
   * Deletes the directory specified by the parameter and all of its contents.
   * This does recurse into subdirectories. Function reports errors. If the
   * parameter does not denote a directory, <b>false </b> is always returned.
   
   @param dir
   *            a File representing the directory to be delete
   @return <b>true </b> if and only if the directory does not exist on
   *         termination; a return value <b>false </b> does not imply that
   *         there were no files deleted
   @throws IllegalArgumentException
   *             if the parameter is <b>null </b>
   */
  public static boolean deleteDirectory(File dir) {
    File[] files;
    File f;
    int i;
    boolean success = true;

    if (dir == null) {
      throw new IllegalArgumentException("dir = null");
    }

    if (!dir.isDirectory()) {
      return false;
    }

    files = dir.listFiles();

    for (i = 0; i < files.length; i++) {
      if ((f = files[i]).isDirectory()) {
        deleteDirectory(f);
      else if (!f.delete()) {
        LOG.severe("*** failed to delete file " + f.getAbsolutePath());
      }
    }

    success = dir.delete();

    if (!success) {
      LOG.severe("*** failed to delete directory "
          + dir.getAbsolutePath());
    }

    return success;
  }

  // deleteDirectory

  /**
   * Deletes the contents of an existing directory. (May be applied to
   * non-existing files without causing error.)
   
   @return <b>true </b> if and only if on termination the directory exists
   *         and is empty
   */
  public static boolean emptyDirectory(File dir) {
    boolean success;

    if (dir == null) {
      throw new IllegalArgumentException("dir = null");
    }

    if ((success = dir.exists() && deleteDirectory(dir))) {
      dir.mkdirs();
    }

    return success && dir.exists();
  }

  // emptyDirectory

  /**
   * General use columba resource InputStream getter.
   
   @param path
   *            the full path and filename of the resource requested. If
   *            <code>path</code> begins with "#" it is resolved against the
   *            program's standard resource folder after removing "#"
   @return an InputStream to read the resource data, or <b>null </b> if the
   *         resource could not be obtained
   @throws java.io.IOException
   *             if there was an error opening the input stream
   */
  public static InputStream getResourceStream(String path)
      throws java.io.IOException {
    URL url;

    if ((url = getResourceURL(path)) == null) {
      return null;
    }
    return url.openStream();
  }

  // getResourceStream

  /**
   * General use columba resource URL getter.
   
   @param path
   *            the full path and filename of the resource requested. If
   *            <code>path</code> begins with "#" it is resolved against the
   *            program's standard resource folder after removing "#"
   @return an URL instance, or <b>null </b> if the resource could not be
   *         obtained
   @throws java.io.IOException
   *             if there was an error opening the input stream
   */
  public static URL getResourceURL(String path// throws
  // java.io.IOException
  {
    URL url;

    if (path == null) {
      throw new IllegalArgumentException("path = null");
    }

    if (path.startsWith("#")) {
      path = resourceFolder + path.substring(1);
    }

    // url = ClassLoader.getSystemResource(path);
    url = DiskIO.class.getResource("/" + path);

    if (url == null) {
      LOG.info("*** failed locating resource: " + path);

      return null;
    }

    return url;
  }

  // getResourceURL
  public static void setResourceRoot(String path) {
    if (path == null) {
      resourceFolder = "";
    else {
      if (!path.endsWith("/")) {
        path += "/";
      }

      resourceFolder = path;
    }
  }

  // setResourceRoot
  public static String getResourceRoot() {
    return resourceFolder;
  }

  /**
   * Copies the contents of any disk file to the specified output file. The
   * output file will be overridden if it exist. Function reports errors.
   
   @param inputFile
   *            a File object
   @param outputFile
   *            a File object
   @throws java.io.IOException
   *             if the function could not be completed because of an IO error
   */
  public static void copyFile(File inputFile, File outputFile)
      throws java.io.IOException {
    FileInputStream in;
    FileOutputStream out;

    byte[] buffer = new byte[512];
    int len;

    try {
      out = new FileOutputStream(outputFile);
      in = new FileInputStream(inputFile);

      while ((len = in.read(buffer)) != -1) {
        out.write(buffer, 0, len);
      }

      in.close();
      out.close();
    catch (IOException e) {
      LOG.info("*** error during file copy "
          + outputFile.getAbsolutePath() ": " + e.getMessage());
      throw e;
    }
  }

  // copyFile

  /**
   * Copies a system resource to the specified output file. The output file
   * will be overridden if it exist, so the calling routine has to take care
   * about unwanted deletions of content. Function reports errors.
   
   @param resource
   *            a full resource path. If the value begins with "#", it is
   *            resolved against the program's standard resource folder after
   *            removing "#"
   @return <b>true </b> if and only if the operation was successful,
   *         <b>false </b> if the resource was not found
   @throws java.io.IOException
   *             if there was an IO error
   */
  public static boolean copyResource(String resource, File outputFile)
      throws java.io.IOException {
    InputStream in;
    FileOutputStream out;
    byte[] buffer = new byte[512];
    int len;

    // attempt
    try {
      if ((in = DiskIO.getResourceStream(resource)) == null) {
        return false;
      }

      out = new FileOutputStream(outputFile);

      while ((len = in.read(buffer)) != -1) {
        out.write(buffer, 0, len);
      }

      out.close();
      in.close();

      LOG.fine("created : " + outputFile.getAbsolutePath());
    catch (IOException e) {
      LOG.severe("*** error during resource file copy "
          + outputFile.getAbsolutePath() ": " + e.getMessage());
      throw e;
    }

    return true;
  }

  // copyResource
  public static String readStringFromResource(String resource)
      throws java.io.IOException {
    InputStream in;

    StringBuffer result = new StringBuffer();

    // attempt
    try {
      if ((in = DiskIO.getResourceStream(resource)) == null) {
        return "";
      }

      BufferedReader reader = new BufferedReader(
          new InputStreamReader(in));

      String nextLine = reader.readLine();

      while (nextLine != null) {
        result.append(nextLine);
        result.append("\n");
        nextLine = reader.readLine();
      }

      in.close();
    catch (IOException e) {
      e.printStackTrace();
      throw e;
    }

    return result.toString();
  }

  /**
   * Results equal
   * <code>copyResource ( String resource, new File (outputFile) )</code>.
   */
  public static boolean copyResource(String resource, String outputFile)
      throws java.io.IOException {
    return copyResource(resource, new File(outputFile));
  }
}

   
    
    
    
    
    
  
Related examples in the same category
1.Create directory
2.Create directory along with required nonexistent parent directories
3.Create directory tree (nested/cascade folders)
4.Create a directories recursively
5.Copying a Directory: Copies files under srcDir to dstDir, if dstDir does not exist, it will be created.
6.Delete a non-empty directory: Deletes all files and subdirectories under dir.
7.Listing the Files or Subdirectories in a Directory
8.Listing the File System Roots
9.The Directory Listing ApplicationThe Directory Listing Application
10.use list( ) to examine the contents of a directory:
11.Reading and Printing a Directory HierarchyReading and Printing a Directory Hierarchy
12.Display a file system in a JTree viewDisplay a file system in a JTree view
13.File Tree DemoFile Tree Demo
14.File Table HTMLFile Table HTML
15.A standalone program that deletes a specified file or directory
16.Get Last modification time of a file or directory
17.Set last modified time of a file or directory
18.List contents of a directory
19.Determine if file or directory exists
20.Determine if File or Directory is hidden
21.Check if a directory is not empty
22.Get name of parent directory
23.Get name of specified file or directory
24.Get current directory
25.Mark file or directory Read Only
26.Rename file or directory
27.Traversing all files and directories under dir
28.Traversing only directories under dir
29.Traversing only files under dir
30.Creates and displays a window containing a list of files and sub-directories in a specified directory
31.Calculate directory size
32.Delete directory recursively
33.Determining If Two Filename Paths Refer to the Same File
34.Recursive directory deletion
35.Recursivly delete directory
36.Searches through the directory tree
37.Starts at the directory given and tests to see whether it is empty
38.Directory Walker
39.Creates a new and empty directory in the default temp directory using the given prefix.
40.Count files in a directory (including files in all subdirectories)
41.Create a unique directory within a directory 'root'
42.Creates a new empty temporary directory.
43.Get Files Recurse
44.Recursively search a directory tree
45.Find directoriesFind directories
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.