Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2007 The Guava Authors
   *
   * 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.
  */
 
 package com.google.common.io;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.io.File;
 import java.util.List;
Provides utility methods for working with files.

All method parameters must be non-null unless documented otherwise.

Author(s):
Chris Nokleberg
Since:
1.0
 
 public final class Files {

  
Maximum loop count when creating temp directories.
 
   private static final int TEMP_DIR_ATTEMPTS = 10000;
 
   private Files() {}

  
Returns a buffered reader that reads from a file using the given character set.

Parameters:
file the file to read from
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the buffered reader
 
   public static BufferedReader newReader(File fileCharset charset)
       throws FileNotFoundException {
     return new BufferedReader(
         new InputStreamReader(new FileInputStream(file), charset));
   }

  
Returns a buffered writer that writes to a file using the given character set.

Parameters:
file the file to write to
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the buffered writer
 
   public static BufferedWriter newWriter(File fileCharset charset)
       throws FileNotFoundException {
     return new BufferedWriter(
         new OutputStreamWriter(new FileOutputStream(file), charset));
   }

  
Returns a factory that will supply instances of java.io.FileInputStream that read from a file.

Parameters:
file the file to read from
Returns:
the factory
      final File file) {
    Preconditions.checkNotNull(file);
    return new InputSupplier<FileInputStream>() {
      @Override
      public FileInputStream getInput() throws IOException {
        return new FileInputStream(file);
      }
    };
  }

  
Returns a factory that will supply instances of java.io.FileOutputStream that write to a file.

Parameters:
file the file to write to
Returns:
the factory
      File file) {
    return newOutputStreamSupplier(filefalse);
  }

  
Returns a factory that will supply instances of java.io.FileOutputStream that write to or append to a file.

Parameters:
file the file to write to
append if true, the encoded characters will be appended to the file; otherwise the file is overwritten
Returns:
the factory
      final File filefinal boolean append) {
    Preconditions.checkNotNull(file);
    return new OutputSupplier<FileOutputStream>() {
      @Override
      public FileOutputStream getOutput() throws IOException {
        return new FileOutputStream(fileappend);
      }
    };
  }

  
Returns a factory that will supply instances of java.io.InputStreamReader that read a file using the given character set.

Parameters:
file the file to read from
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the factory
      Charset charset) {
    return CharStreams.newReaderSupplier(newInputStreamSupplier(file), charset);
  }

  
Returns a factory that will supply instances of java.io.OutputStreamWriter that write to a file using the given character set.

Parameters:
file the file to write to
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the factory
      Charset charset) {
    return newWriterSupplier(filecharsetfalse);
  }

  
Returns a factory that will supply instances of java.io.OutputStreamWriter that write to or append to a file using the given character set.

Parameters:
file the file to write to
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
append if true, the encoded characters will be appended to the file; otherwise the file is overwritten
Returns:
the factory
      Charset charsetboolean append) {
    return CharStreams.newWriterSupplier(newOutputStreamSupplier(fileappend),
        charset);
  }

  
Reads all bytes from a file into a byte array.

Parameters:
file the file to read from
Returns:
a byte array containing all the bytes from file
Throws:
java.lang.IllegalArgumentException if the file is bigger than the largest possible byte array (2^31 - 1)
java.io.IOException if an I/O error occurs
  public static byte[] toByteArray(File filethrows IOException {
    Preconditions.checkArgument(file.length() <= .);
    if (file.length() == 0) {
      // Some special files are length 0 but have content nonetheless.
      return ByteStreams.toByteArray(newInputStreamSupplier(file));
    } else {
      // Avoid an extra allocation and copy.
      byte[] b = new byte[(intfile.length()];
      boolean threw = true;
      InputStream in = new FileInputStream(file);
      try {
        ByteStreams.readFully(inb);
        threw = false;
      } finally {
        Closeables.close(inthrew);
      }
      return b;
    }
  }

  
Reads all characters from a file into a java.lang.String, using the given character set.

Parameters:
file the file to read from
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
a string containing all the characters from the file
Throws:
java.io.IOException if an I/O error occurs
  public static String toString(File fileCharset charsetthrows IOException {
    return new String(toByteArray(file), charset.name());
  }

  
Copies to a file all bytes from an java.io.InputStream supplied by a factory.

Parameters:
from the input factory
to the destination file
Throws:
java.io.IOException if an I/O error occurs
  public static void copy(InputSupplier<? extends InputStreamfromFile to)
      throws IOException {
    ByteStreams.copy(fromnewOutputStreamSupplier(to));
  }

  
Overwrites a file with the contents of a byte array.

Parameters:
from the bytes to write
to the destination file
Throws:
java.io.IOException if an I/O error occurs
  public static void write(byte[] fromFile tothrows IOException {
    ByteStreams.write(fromnewOutputStreamSupplier(to));
  }

  
Copies all bytes from a file to an java.io.OutputStream supplied by a factory.

Parameters:
from the source file
to the output factory
Throws:
java.io.IOException if an I/O error occurs
  public static void copy(File fromOutputSupplier<? extends OutputStreamto)
      throws IOException {
    ByteStreams.copy(newInputStreamSupplier(from), to);
  }

  
Copies all bytes from a file to an output stream.

Parameters:
from the source file
to the output stream
Throws:
java.io.IOException if an I/O error occurs
  public static void copy(File fromOutputStream tothrows IOException {
    ByteStreams.copy(newInputStreamSupplier(from), to);
  }

  
Copies all the bytes from one file to another. .

Parameters:
from the source file
to the destination file
Throws:
java.io.IOException if an I/O error occurs
java.lang.IllegalArgumentException if from.equals(to)
  public static void copy(File fromFile tothrows IOException {
    Preconditions.checkArgument(!from.equals(to),
        "Source %s and destination %s must be different"fromto);
    copy(newInputStreamSupplier(from), to);
  }

  
Copies to a file all characters from a java.lang.Readable and java.io.Closeable object supplied by a factory, using the given character set.

Parameters:
from the readable supplier
to the destination file
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
Throws:
java.io.IOException if an I/O error occurs
  public static <R extends Readable & Closeablevoid copy(
      InputSupplier<R> fromFile toCharset charsetthrows IOException {
    CharStreams.copy(fromnewWriterSupplier(tocharset));
  }

  
Writes a character sequence (such as a string) to a file using the given character set.

Parameters:
from the character sequence to write
to the destination file
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
Throws:
java.io.IOException if an I/O error occurs
  public static void write(CharSequence fromFile toCharset charset)
      throws IOException {
    write(fromtocharsetfalse);
  }

  
Appends a character sequence (such as a string) to a file using the given character set.

Parameters:
from the character sequence to append
to the destination file
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
Throws:
java.io.IOException if an I/O error occurs
  public static void append(CharSequence fromFile toCharset charset)
      throws IOException {
    write(fromtocharsettrue);
  }

  
Private helper method. Writes a character sequence to a file, optionally appending.

Parameters:
from the character sequence to append
to the destination file
charset the charset used to encode the output stream; see com.google.common.base.Charsets for helpful predefined constants
append true to append, false to overwrite
Throws:
java.io.IOException if an I/O error occurs
  private static void write(CharSequence fromFile toCharset charset,
      boolean appendthrows IOException {
    CharStreams.write(fromnewWriterSupplier(tocharsetappend));
  }

  
Copies all characters from a file to a java.lang.Appendable & java.io.Closeable object supplied by a factory, using the given character set.

Parameters:
from the source file
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
to the appendable supplier
Throws:
java.io.IOException if an I/O error occurs
  public static <W extends Appendable & Closeablevoid copy(File from,
      Charset charsetOutputSupplier<W> tothrows IOException {
    CharStreams.copy(newReaderSupplier(fromcharset), to);
  }

  
Copies all characters from a file to an appendable object, using the given character set.

Parameters:
from the source file
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
to the appendable object
Throws:
java.io.IOException if an I/O error occurs
  public static void copy(File fromCharset charsetAppendable to)
      throws IOException {
    CharStreams.copy(newReaderSupplier(fromcharset), to);
  }

  
Returns true if the files contains the same bytes.

Throws:
java.io.IOException if an I/O error occurs
  public static boolean equal(File file1File file2throws IOException {
    if (file1 == file2 || file1.equals(file2)) {
      return true;
    }
    /*
     * Some operating systems may return zero as the length for files
     * denoting system-dependent entities such as devices or pipes, in
     * which case we must fall back on comparing the bytes directly.
     */
    long len1 = file1.length();
    long len2 = file2.length();
    if (len1 != 0 && len2 != 0 && len1 != len2) {
      return false;
    }
    return ByteStreams.equal(newInputStreamSupplier(file1),
        newInputStreamSupplier(file2));
  }

  
Atomically creates a new directory somewhere beneath the system's temporary directory (as defined by the java.io.tmpdir system property), and returns its name.

Use this method instead of java.io.File.createTempFile(java.lang.String,java.lang.String) when you wish to create a directory, not a regular file. A common pitfall is to call createTempFile, delete the file and create a directory in its place, but this leads a race condition which can be exploited to create security vulnerabilities, especially when executable files are to be written into the directory.

This method assumes that the temporary volume is writable, has free inodes and free blocks, and that it will not be called thousands of times per second.

Returns:
the newly-created directory
Throws:
java.lang.IllegalStateException if the directory could not be created
  public static File createTempDir() {
    File baseDir = new File(System.getProperty("java.io.tmpdir"));
    String baseName = System.currentTimeMillis() + "-";
    for (int counter = 0; counter < counter++) {
      File tempDir = new File(baseDirbaseName + counter);
      if (tempDir.mkdir()) {
        return tempDir;
      }
    }
    throw new IllegalStateException("Failed to create directory within "
        +  + " attempts (tried "
        + baseName + "0 to " + baseName + ( - 1) + ')');
  }

  
Creates an empty file or updates the last updated timestamp on the same as the unix command of the same name.

Parameters:
file the file to create or update
Throws:
java.io.IOException if an I/O error occurs
  public static void touch(File filethrows IOException {
    if (!file.createNewFile()
        && !file.setLastModified(System.currentTimeMillis())) {
      throw new IOException("Unable to update modification time of " + file);
    }
  }

  
Creates any necessary but nonexistent parent directories of the specified file. Note that if this operation fails it may have succeeded in creating some (but not all) of the necessary parent directories.

Throws:
java.io.IOException if an I/O error occurs, or if any necessary but nonexistent parent directories of the specified file could not be created.
Since:
4.0
  public static void createParentDirs(File filethrows IOException {
    File parent = file.getCanonicalFile().getParentFile();
    if (parent == null) {
      /*
       * The given directory is a filesystem root. All zero of its ancestors
       * exist. This doesn't mean that the root itself exists -- consider x:\ on
       * a Windows machine without such a drive -- or even that the caller can
       * create it, but this method makes no such guarantees even for non-root
       * files.
       */
      return;
    }
    parent.mkdirs();
    if (!parent.isDirectory()) {
      throw new IOException("Unable to create parent directories of " + file);
    }
  }

  
Moves the file from one path to another. This method can rename a file or move it to a different directory, like the Unix mv command.

Parameters:
from the source file
to the destination file
Throws:
java.io.IOException if an I/O error occurs
java.lang.IllegalArgumentException if from.equals(to)
  public static void move(File fromFile tothrows IOException {
    Preconditions.checkNotNull(to);
    Preconditions.checkArgument(!from.equals(to),
        "Source %s and destination %s must be different"fromto);
    if (!from.renameTo(to)) {
      copy(fromto);
      if (!from.delete()) {
        if (!to.delete()) {
          throw new IOException("Unable to delete " + to);
        }
        throw new IOException("Unable to delete " + from);
      }
    }
  }

  
Reads the first line from a file. The line does not include line-termination characters, but does include other leading and trailing whitespace.

Parameters:
file the file to read from
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
the first line, or null if the file is empty
Throws:
java.io.IOException if an I/O error occurs
  public static String readFirstLine(File fileCharset charset)
      throws IOException {
    return CharStreams.readFirstLine(Files.newReaderSupplier(filecharset));
  }

  
Reads all of the lines from a file. The lines do not include line-termination characters, but do include other leading and trailing whitespace.

Parameters:
file the file to read from
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
Returns:
a mutable java.util.List containing all the lines
Throws:
java.io.IOException if an I/O error occurs
  public static List<StringreadLines(File fileCharset charset)
      throws IOException {
    return CharStreams.readLines(Files.newReaderSupplier(filecharset));
  }

  
Streams lines from a java.io.File, stopping when our callback returns false, or we have read all of the lines.

Parameters:
file the file to read from
charset the charset used to decode the input stream; see com.google.common.base.Charsets for helpful predefined constants
callback the com.google.common.io.LineProcessor to use to handle the lines
Returns:
the output of processing the lines
Throws:
java.io.IOException if an I/O error occurs
  public static <T> T readLines(File fileCharset charset,
      LineProcessor<T> callbackthrows IOException {
    return CharStreams.readLines(Files.newReaderSupplier(filecharset),
        callback);
  }

  
Process the bytes of a file.

(If this seems too complicated, maybe you're looking for toByteArray(java.io.File).)

Parameters:
file the file to read
processor the object to which the bytes of the file are passed.
Returns:
the result of the byte processor
Throws:
java.io.IOException if an I/O error occurs
  public static <T> T readBytes(File fileByteProcessor<T> processor)
      throws IOException {
    return ByteStreams.readBytes(newInputStreamSupplier(file), processor);
  }

  
Computes and returns the checksum value for a file. The checksum object is reset when this method returns successfully.

Parameters:
file the file to read
checksum the checksum object
Returns:
the result of java.util.zip.Checksum.getValue() after updating the checksum object with all of the bytes in the file
Throws:
java.io.IOException if an I/O error occurs
  public static long getChecksum(File fileChecksum checksum)
      throws IOException {
    return ByteStreams.getChecksum(newInputStreamSupplier(file), checksum);
  }

  
Computes the hash code of the file using hashFunction.

Parameters:
file the file to read
hashFunction the hash function to use to hash the data
Returns:
the com.google.common.hash.HashCode of all of the bytes in the file
Throws:
java.io.IOException if an I/O error occurs
Since:
12.0
  public static HashCode hash(File fileHashFunction hashFunction)
      throws IOException {
    return ByteStreams.hash(newInputStreamSupplier(file), hashFunction);
  }

  
Fully maps a file read-only in to memory as per java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode,long,long).

Files are mapped from offset 0 to its length.

This only works for files <= java.lang.Integer.MAX_VALUE bytes.

Parameters:
file the file to map
Returns:
a read-only buffer reflecting file
Throws:
java.io.FileNotFoundException if the file does not exist
java.io.IOException if an I/O error occurs
Since:
2.0
See also:
java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode,long,long)
  public static MappedByteBuffer map(File filethrows IOException {
    return map(file.);
  }

  
Fully maps a file in to memory as per java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode,long,long) using the requested java.nio.channels.FileChannel.MapMode.

Files are mapped from offset 0 to its length.

This only works for files <= java.lang.Integer.MAX_VALUE bytes.

Parameters:
file the file to map
mode the mode to use when mapping file
Returns:
a buffer reflecting file
Throws:
java.io.FileNotFoundException if the file does not exist
java.io.IOException if an I/O error occurs
Since:
2.0
See also:
java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode,long,long)
  public static MappedByteBuffer map(File fileMapMode mode)
      throws IOException {
    if (!file.exists()) {
      throw new FileNotFoundException(file.toString());
    }
    return map(filemodefile.length());
  }

  
Maps a file in to memory as per java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode,long,long) using the requested java.nio.channels.FileChannel.MapMode.

Files are mapped from offset 0 to size.

If the mode is java.nio.channels.FileChannel.MapMode.READ_WRITE and the file does not exist, it will be created with the requested size. Thus this method is useful for creating memory mapped files which do not yet exist.

This only works for files <= java.lang.Integer.MAX_VALUE bytes.

Parameters:
file the file to map
mode the mode to use when mapping file
Returns:
a buffer reflecting file
Throws:
java.io.IOException if an I/O error occurs
Since:
2.0
See also:
java.nio.channels.FileChannel.map(java.nio.channels.FileChannel.MapMode,long,long)
  public static MappedByteBuffer map(File fileMapMode modelong size)
      throws FileNotFoundExceptionIOException {
    RandomAccessFile raf =
        new RandomAccessFile(filemode == . ? "r" : "rw");
    boolean threw = true;
    try {
      MappedByteBuffer mbb = map(rafmodesize);
      threw = false;
      return mbb;
    } finally {
      Closeables.close(rafthrew);
    }
  }
  private static MappedByteBuffer map(RandomAccessFile rafMapMode mode,
      long sizethrows IOException {
    FileChannel channel = raf.getChannel();
    boolean threw = true;
    try {
      MappedByteBuffer mbb = channel.map(mode, 0, size);
      threw = false;
      return mbb;
    } finally {
      Closeables.close(channelthrew);
    }
  }

  
Returns the lexically cleaned form of the path name, usually (but not always) equivalent to the original. The following heuristics are used:
  • empty string becomes .
  • . stays as .
  • fold out ./
  • fold out ../ when possible
  • collapse multiple slashes
  • delete trailing slashes (unless the path is just "/")
These heuristics do not always match the behavior of the filesystem. In particular, consider the path a/../b, which simplifyPath will change to b. If a is a symlink to x, a/../b may refer to a sibling of x, rather than the sibling of a referred to by b.

Since:
11.0
  public static String simplifyPath(String pathname) {
    if (pathname.length() == 0) {
      return ".";
    }
    // split the path apart
    Iterable<Stringcomponents =
        Splitter.on('/').omitEmptyStrings().split(pathname);
    List<Stringpath = new ArrayList<String>();
    // resolve ., .., and //
    for (String component : components) {
      if (component.equals(".")) {
        continue;
      } else if (component.equals("..")) {
        if (path.size() > 0 && !path.get(path.size() - 1).equals("..")) {
          path.remove(path.size() - 1);
        } else {
          path.add("..");
        }
      } else {
        path.add(component);
      }
    }
    // put it back together
    String result = Joiner.on('/').join(path);
    if (pathname.charAt(0) == '/') {
      result = "/" + result;
    }
    while (result.startsWith("/../")) {
      result = result.substring(3);
    }
    if (result.equals("/..")) {
      result = "/";
    } else if ("".equals(result)) {
      result = ".";
    }
    return result;
  }

  
Returns the file extension for the given file name, or the empty string if the file has no extension. The result does not include the '.'.

Since:
11.0
  public static String getFileExtension(String fileName) {
    checkNotNull(fileName);
    int dotIndex = fileName.lastIndexOf('.');
    return (dotIndex == -1) ? "" : fileName.substring(dotIndex + 1);
  }
New to GrepCode? Check out our FAQ X