в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== 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 <em>first</em> 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>

Java Tutorial/File/Directory - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010

← Предыдущая	Версия 05:20, 1 июня 2010
(нет различий)