Java Tutorial/File/Directory

Calculate directory size

   <source lang="java">

import java.io.File; import org.apache.rumons.io.FileUtils; public class Main {

 public static void main(String[] args) {
   long size = FileUtils.sizeOfDirectory(new File("C:/Windows"));
   System.out.println("Size: " + size + " bytes");
 }

}</source>

Change last modified time of a file or directory

   <source lang="java">

import java.io.File; import java.util.Date; public class Main {

 public static void main(String[] args) throws Exception {
   File fileToChange = new File("C:/myfile.txt");
   Date filetime = new Date(fileToChange.lastModified());
   System.out.println(filetime.toString());
   System.out.println(fileToChange.setLastModified(System.currentTimeMillis()));
   filetime = new Date(fileToChange.lastModified());
   System.out.println(filetime.toString());
 }

}</source>

Check if a directory is not empty

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("/data");
   if (file.isDirectory()) {
     String[] files = file.list();
     if (files.length > 0) {
       System.out.println("The " + file.getPath() + " is not empty!");
     }
   }
 }

}</source>

Checks, whether the child directory is a subdirectory of the base directory.

   <source lang="java">

import java.io.File; import java.io.IOException; /*

* JCommon : a free general purpose class library for the Java(tm) platform
* 
*
* (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
* 
* Project Info:  http://www.jfree.org/jcommon/index.html
*
* This library is free software; you can redistribute it and/or modify it 
* under the terms of the GNU Lesser General Public License as published by 
* the Free Software Foundation; either version 2.1 of the License, or 
* (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but 
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
* USA.  
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
* in the United States and other countries.]
* 
* ------------
* IOUtils.java
* ------------
* (C)opyright 2002-2004, by Thomas Morgner and Contributors.
*
* Original Author:  Thomas Morgner;
* Contributor(s):   David Gilbert (for Object Refinery Limited);
*
* $Id: IOUtils.java,v 1.8 2009/01/22 08:34:58 taqua Exp $
*
* Changes
* -------
* 26-Jan-2003 : Initial version
* 23-Feb-2003 : Documentation
* 25-Feb-2003 : Fixed Checkstyle issues (DG);
* 29-Apr-2003 : Moved to jcommon
* 04-Jan-2004 : Fixed JDK 1.2.2 issues with createRelativeURL;
*               added support for query strings within these urls (TM);
*/

/**

* The IOUtils provide some IO related helper methods.
*
* @author Thomas Morgner.
*/

public class Main {

 /**
  * Checks, whether the child directory is a subdirectory of the base 
  * directory.
  *
  * @param base the base directory.
  * @param child the suspected child directory.
  * @return true, if the child is a subdirectory of the base directory.
  * @throws IOException if an IOError occured during the test.
  */
 public boolean isSubDirectory(File base, File child)
     throws IOException {
     base = base.getCanonicalFile();
     child = child.getCanonicalFile();
     File parentFile = child;
     while (parentFile != null) {
         if (base.equals(parentFile)) {
             return true;
         }
         parentFile = parentFile.getParentFile();
     }
     return false;
 }

}</source>

Copying a Directory

   <source lang="java">

import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class Main {

 public static void main(String[] argv) throws Exception {
   copyDirectory(new File("srcDir"), new File("dstDir"));
 }
 public static void copyDirectory(File srcDir, File dstDir) throws IOException {
   if (srcDir.isDirectory()) {
     if (!dstDir.exists()) {
       dstDir.mkdir();
     }
     String[] children = srcDir.list();
     for (int i = 0; i < children.length; i++) {
       copyDirectory(new File(srcDir, children[i]), new File(dstDir, children[i]));
     }
   } else {
     copyFile(srcDir, dstDir);
   }
 }
 static void copyFile(File src, File dst) throws IOException {
   InputStream in = new FileInputStream(src);
   OutputStream out = new FileOutputStream(dst);
   // Transfer bytes from in to out
   byte[] buf = new byte[1024];
   int len;
   while ((len = in.read(buf)) > 0) {
     out.write(buf, 0, len);
   }
   in.close();
   out.close();
 }

}</source>

Create a directories recursively

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   String directories = "D:\\a\\b\\c\\d\\e\\f\\g\\h\\i";
   File file = new File(directories);
   boolean result = file.mkdirs();
   System.out.println("Status = " + result);
 }

}</source>

Create a directory; all ancestor directories must exist

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
   boolean success = (new File("directoryName")).mkdir();
   if (!success) {
     System.out.println("Directory creation failed"); 
   }
 }

}</source>

Create a directory; all non-existent ancestor directories are automatically created

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
   boolean success = (new File("directoryName")).mkdirs();
   if (!success) {
     System.out.println("Directory creation failed");
   }
 }

}</source>

Create a directory (or several directories)

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File directory = new File("C:/temp/temp1/temp2/temp3");
   if (directory.mkdir()) {
     System.out.println("Success mkdir");
   } else {
     if (directory.mkdirs()) {
       System.out.println("Success mkdirs");
     } else {
       System.out.println("Failed");
     }
   }
 }

}</source>

Create directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File dir = new File("C:/FileIO/DemoDirectory");
   boolean isDirectoryCreated = dir.mkdir();
   if (isDirectoryCreated) {
     System.out.println("successfully");
   } else {
     System.out.println("not");
   }
 }

}</source>

Create directory along with required nonexistent parent directories

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File dir = new File("C:/1/Parent1/Parent2/DemoDir");
   boolean isDirCreated = dir.mkdirs();
   if (isDirCreated)
     System.out.println("created");
   else
     System.out.println("Failed");
 }

}</source>

Creates a new and empty directory in the default temp directory using the given prefix.

   <source lang="java">

/*

* Copyright Aduna (http://www.aduna-software.ru/) (c) 1997-2006.
*
* Licensed under the Aduna BSD-style license.
*/

import java.io.File; import java.io.IOException; public class Main {

 /**
  * Creates a new and empty directory in the default temp directory using the
  * given prefix. This methods uses {@link File#createTempFile} to create a
  * new tmp file, deletes it and creates a directory for it instead.
  * 
  * @param prefix The prefix string to be used in generating the diretory"s
  * name; must be at least three characters long.
  * @return A newly-created empty directory.
  * @throws IOException If no directory could be created.
  */
 public static File createTempDir(String prefix)
   throws IOException
 {
   String tmpDirStr = System.getProperty("java.io.tmpdir");
   if (tmpDirStr == null) {
     throw new IOException(
       "System property "java.io.tmpdir" does not specify a tmp dir");
   }
   
   File tmpDir = new File(tmpDirStr);
   if (!tmpDir.exists()) {
     boolean created = tmpDir.mkdirs();
     if (!created) {
       throw new IOException("Unable to create tmp dir " + tmpDir);
     }
   }
   
   File resultDir = null;
   int suffix = (int)System.currentTimeMillis();
   int failureCount = 0;
   do {
     resultDir = new File(tmpDir, prefix + suffix % 10000);
     suffix++;
     failureCount++;
   }
   while (resultDir.exists() && failureCount < 50);
   
   if (resultDir.exists()) {
     throw new IOException(failureCount + 
       " attempts to generate a non-existent directory name failed, giving up");
   }
   boolean created = resultDir.mkdir();
   if (!created) {
     throw new IOException("Failed to create tmp directory");
   }
   
   return resultDir;
 }

}</source>

Delete directory recursively

   <source lang="java">

import org.apache.rumons.io.FileUtils; import java.io.File; import java.io.IOException; public class Main {

 public static void main(String[] args) throws Exception {
   File directory = new File("c:\\");
   FileUtils.deleteDirectory(directory);
 }

}</source>

Delete file or directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) throws Exception {
   File file = new File("C:/Demo.txt");
   System.out.println(file.delete());
 }

}</source>

Delete file or directory when virtual machine terminates

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/Demo.txt");
   file.deleteOnExit();
 }

}</source>

Deleting a Directory (an empty directory)

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
   boolean success = (new File("directoryName")).delete();
   if (!success) {
     System.out.println("Deletion failed");
   }
 }

}</source>

Determine File or Directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C://FileIO");
   boolean isFile = file.isFile();
   if (isFile){
     System.out.println("a file.");
   }else{
     System.out.println("not a file.");
   }
   boolean isDirectory = file.isDirectory();
   if (isDirectory){
     System.out.println("a directory.");
   }else{
     System.out.println("not a directory.");
   }
 }

}</source>

Determine if file or directory exists

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/Demo.txt");
   System.out.println(file.exists());
 }

}</source>

Determine if File or Directory is hidden

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/Demo.txt");
   System.out.println(file.isHidden());
 }

}</source>

Get all files and folders under a certain folder and save them to a set

   <source lang="java">

import java.io.File; import java.util.HashSet; import java.util.Set; public class Main {

 public static void main(String[] argv) {
   Set<File> all = new HashSet<File>();
   getAllFileAndFolder(new File("c:\\"), all);
 }
 public static void getAllFileAndFolder(File folder, Set<File> all) {
   all.add(folder);
   if (folder.isFile()) {
     return;
   }
   for (File file : folder.listFiles()) {
     all.add(file);
     if (file.isDirectory()) {
       getAllFileAndFolder(file, all);
     }
   }
 }

}</source>

Get name of parent directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/demo.txt");
   System.out.println("Parent directory:" + file.getParent());
 }

}</source>

Get name of specified file or directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/Demo.txt");
   System.out.println("File name is : " + file.getName());
 }

}</source>

Get parent directory as a File object

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/demo.txt");
   File fileParent = file.getParentFile();
   System.out.println("Parent directory: " + fileParent.getPath());
 }

}</source>

Get the content of a directory

   <source lang="java">

import java.io.File; import java.io.FilenameFilter; public class Main {

 public static void main(String[] args) {
   File games = new File("C:\\Test");
   File[] files = games.listFiles();
   for (File file : files) {
     System.out.println(file + " is a " + (file.isDirectory() ? "directory" : "file"));
   }
   String[] xfiles = games.list();
   for (String file : xfiles) {
     System.out.println("File = " + file);
   }
   FilenameFilter filter = new FilenameFilter() {
     public boolean accept(File dir, String name) {
       if (name.endsWith(".txt")) {
         return true;
       }
       return false;
     }
   };
   File[] yfiles = games.listFiles(filter);
   for (File doc : yfiles) {
     System.out.println("Doc file = " + doc);
   }
 }

}</source>

Getting the Current Working Directory

   <source lang="java">

public class Main {

 public static void main(String[] argv) throws Exception {
   String curDir = System.getProperty("user.dir");
 }

}</source>

If a file or directory readable

   <source lang="java">

import java.io.File; import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File(args[0]);
   if (!file.exists()) {
     System.out.println(args[0] + " does not exist.");
     return;
   }
   if (file.isFile() && file.canRead()){
     System.out.println(file.getName() + " can be read from.");
   }
   if (file.isDirectory()) {
     System.out.println(file.getPath() + " is a directory containing...");
     String[] files = file.list();
     for (int i = 0; i < files.length; i++) {
       System.out.println(files[i]);
     }
   }
 }

}</source>

Mark file or directory Read Only

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File file = new File("C:/demo.txt");
   System.out.println(file.setReadOnly());
   System.out.println(file.canWrite());
 }

}</source>

Moving a File or Directory to Another Directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
   File file = new File("filename");
   File dir = new File("directoryname");
   boolean success = file.renameTo(new File(dir, file.getName()));
   if (!success) {
     System.out.println("File was not successfully moved");
   }
 }

}</source>

Recursively search a directory tree

   <source lang="java">

/*

* Copyright 2007 Google Inc.
*
* 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.FileNotFoundException; import java.io.InputStream; /**

* Recursively search a directory tree, for each File found in it, call
* FileFinderListener.proceedFile. A filter can be set prior calling this
* method.
* 
* @author ycoppel@google.ru (Yohann Coppel)
* 
*/

public class FileLister {

 /**
  * Base directory to explore.
  */
 private File classPath;
 /**
  * File listener for callbacks.
  */
 private FileListerListener listener;
 /**
  * @param classPath
  *          path to the classFile (usually top level package as com in
  *          com.google.rumon)
  */
 public FileLister(File classPath, FileListerListener depmk) {
   this.classPath = classPath;
   this.listener = depmk;
 }
 /**
  * begin the search of class files in the classPath given to the constructor.
  */
 public void start() {
   listener.startProcessing();
   for (File f : classPath.listFiles()) {
     dfsFileSearch(f);
   }
   listener.endOfProcessing();
 }
 /**
  * operate a recursive depth first search in the directory. If file is a
  * directory, recursively search into for files. For each file found, check if
  * it passes the filter of DepMaker, and if yes, call proceedFile with the
  * file.
  * 
  * @param file
  *          File where to start the dfsFileSearch
  */
 private void dfsFileSearch(File file) {
   boolean dirMatches = listener.directoryFilter(file.getPath());
   if (file.isDirectory()) {
     // call callback for entering the directory only if the directory matches
     if (dirMatches) {
       listener.enterDirectory(file.getPath().replaceFirst(classPath.getPath(), ""));
     }
     // look inside of the directory anyway (maybe sub directories matches...
     for (File f : file.listFiles()) {
       dfsFileSearch(f);
     }
     // get out of the directory, callback.
     if (dirMatches) {
       listener.outDirectory(file.getPath().replaceFirst(classPath.getPath(), ""));
     }
   } else { // dir.isFile() == true
     if (listener.fileFilter(file.getPath()) && dirMatches) {
       try {
         listener.proceedFile(new FileInputStream(file), file.getPath().replaceFirst(
             classPath.getPath(), ""));
       } catch (FileNotFoundException e) {
         // should not happen, cause we just seen it on the hard drive...
         // but who knows...
         e.printStackTrace();
       }
     }
   }
 }

} /*

* Copyright 2007 Google Inc.
* 
* 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.
*/

/**

* Listener for callbacks when directories and files are found when exploring a
* directory, or a jar file for example.
* 
* @author ycoppel@google.ru (Yohann Coppel)
* 
*/

interface FileListerListener {

 /**
  * Filter to apply to (normal - i.e not a directory) files found in the
  * directory. May be a simple filename check as "end with .class"
  * 
  * @param name
  *          filename
  * @return true if the filename pass the filter, and that proceedFile should
  *         be called on this file later
  * 
  */
 public boolean fileFilter(String name);
 /**
  * Filter to apply to directories. If this methods return false,
  * subdirectories should not be traversed. May be a simple directory path
  * check as "start with "directoryfilter""
  * 
  * @param name
  *          filename to check
  * @return true if the directory can contain interresting files.
  */
 public boolean directoryFilter(String name);
 /**
  * method called when a file passing the fileFilter test is found.
  * 
  * @param f
  *          file found.
  */
 public void proceedFile(InputStream f, String name);
 /**
  * called when entering in the given directory
  * 
  * @param directoryPath
  */
 public void enterDirectory(String directoryPath);
 /**
  * called when we step out from the given directory
  * 
  * @param directoryPath
  */
 public void outDirectory(String directoryPath);
 /**
  * callback called at the begining of the processing
  */
 public void startProcessing();
 /**
  * callback called at the end of the processing
  */
 public void endOfProcessing();

}</source>

Rename file or directory

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] args) {
   File oldName = new File("C:/s.txt");
   File newName = new File("C:/d.txt");
   if (oldName.renameTo(newName)) {
     System.out.println("renamed");
   } else {
     System.out.println("Error");
   }
 }

}</source>

Searches through the directory tree

   <source lang="java">

/*

* 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; /**

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

public final class FileUtils {

 /**
  * 
  * This is a convenience method that calls find(File, String, boolean) with
  * the last parameter set to "false" (does not match directories).
  * 
  * @see #find(File, String, boolean)
  * 
  */
 public static File find(File contextRoot, String fileName) {
   return find(contextRoot, fileName, false);
 }
 /**
  * 
  * Searches through the directory tree under the given context directory and
  * finds the first file that matches the file name. If the third parameter is
  * true, the method will also try to match directories, not just "regular"
  * files.
  * 
  * @param contextRoot
  *          The directory to start the search from.
  * 
  * @param fileName
  *          The name of the file (or directory) to search for.
  * 
  * @param matchDirectories
  *          True if the method should try and match the name against directory
  *          names, not just file names.
  * 
  * @return The java.io.File representing the first file or
  *         directory with the given name, or null if it was not found.
  * 
  */
 public static File find(File contextRoot, String fileName, boolean matchDirectories) {
   if (contextRoot == null)
     throw new NullPointerException("NullContextRoot");
   if (fileName == null)
     throw new NullPointerException("NullFileName");
   if (!contextRoot.isDirectory()) {
     Object[] filler = { contextRoot.getAbsolutePath() };
     String message = "NotDirectory";
     throw new IllegalArgumentException(message);
   }
   File[] files = contextRoot.listFiles();
   //
   // for all children of the current directory...
   //
   for (int n = 0; n < files.length; ++n) {
     String nextName = files[n].getName();
     //
     // if we find a directory, there are two possibilities:
     //
     // 1. the names match, AND we are told to match directories.
     // in this case we"re done
     //
     // 2. not told to match directories, so recurse
     //
     if (files[n].isDirectory()) {
       if (nextName.equals(fileName) && matchDirectories)
         return files[n];
       File match = find(files[n], fileName);
       if (match != null)
         return match;
     }
     //
     // in the case of regular files, just check the names
     //
     else if (nextName.equals(fileName))
       return files[n];
   }
   return null;
 }

}</source>

Search for files recursively

   <source lang="java">

import org.apache.rumons.io.FileUtils; import java.io.File; import java.util.Collection; import java.util.Iterator; public class Main {

 public static void main(String[] args) throws Exception {
   File root = new File("c:\\");
   String[] extensions = { "xml", "java", "dat" };
   boolean recursive = true;
   Collection files = FileUtils.listFiles(root, extensions, recursive);
   for (Iterator iterator = files.iterator(); iterator.hasNext();) {
     File file = (File) iterator.next();
     System.out.println("File = " + file.getAbsolutePath());
   }
 }

}</source>

Traversing all files and directories under dir

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
 }
 
 public static void visitAllDirsAndFiles(File dir) {
   System.out.println(dir);
   if (dir.isDirectory()) {
     String[] children = dir.list();
     for (int i = 0; i < children.length; i++) {
       visitAllDirsAndFiles(new File(dir, children[i]));
     }
   }
 }

}</source>

Traversing only directories under dir

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
 }
 // Process only directories under dir
 public static void visitAllDirs(File dir) {
   if (dir.isDirectory()) {
     System.out.println(dir);
     String[] children = dir.list();
     for (int i = 0; i < children.length; i++) {
       visitAllDirs(new File(dir, children[i]));
     }
   }
 }

}</source>

Traversing only files under dir

   <source lang="java">

import java.io.File; public class Main {

 public static void main(String[] argv) throws Exception {
 }
 public static void visitAllFiles(File dir) {
   if (dir.isDirectory()) {
     String[] children = dir.list();
     for (int i = 0; i < children.length; i++) {
       visitAllFiles(new File(dir, children[i]));
     }
   } else {
     System.out.println(dir);
   }
 }

}</source>