java.io.File.realpath java code examples

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

/**
 * Returns the canonical path of this file.
 * An <i>absolute</i> path is one that begins at the root of the file system.
 * A <i>canonical</i> path is an absolute path with symbolic links
 * and references to "." or ".." resolved. If a path element does not exist (or
 * is not searchable), there is a conflict between interpreting canonicalization
 * as a textual operation (where "a/../b" is "b" even if "a" does not exist) .
 *
 * <p>Most callers should use {@link #getAbsolutePath} instead. A canonical path is
 * significantly more expensive to compute, and not generally useful. The primary
 * use for canonical paths is determining whether two paths point to the same file by
 * comparing the canonicalized paths.
 *
 * <p>It can be actively harmful to use a canonical path, specifically because
 * canonicalization removes symbolic links. It's wise to assume that a symbolic link
 * is present for a reason, and that that reason is because the link may need to change.
 * Canonicalization removes this layer of indirection. Good code should generally avoid
 * caching canonical paths.
 *
 * @return the canonical path of this file.
 * @throws IOException
 *             if an I/O error occurs.
 */
public String getCanonicalPath() throws IOException {
  return realpath(getAbsolutePath());
}

Javadoc

TODO: move this stuff to libcore.os.

Popular methods of File

<init>
Creates a new File instance by converting the givenfile: URI into an abstract pathname. The exact fo
exists
Tests whether the file or directory denoted by this abstract pathname exists.
getAbsolutePath
Returns the absolute pathname string of this abstract pathname. If this abstract pathname is already
getName
Returns the name of the file or directory denoted by this abstract pathname. This is just the last n
isDirectory
mkdirs
delete
Deletes the file or directory denoted by this abstract pathname. If this pathname denotes a director
listFiles
Returns an array of abstract pathnames denoting the files and directories in the directory denoted b
getParentFile
Returns the abstract pathname of this abstract pathname's parent, or null if this pathname does not
getPath
Converts this abstract pathname into a pathname string. The resulting string uses the #separator to
isFile
length
Returns the length of the file denoted by this abstract pathname. The return value is unspecified if

Popular in Java

Parsing JSON documents to java classes using gson
setScale (BigDecimal)
notifyDataSetChanged (ArrayAdapter)
scheduleAtFixedRate (Timer)
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
TimeZone (java.util)
TimeZone represents a time zone offset, and also figures out daylight savings. Typically, you get a
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if
FileUtils (org.apache.commons.io)
General file manipulation utilities. Facilities are provided in the following areas: * writing to a
Top 12 Jupyter Notebook Extensions

How to use realpathmethodin java.io.File

Best Java code snippets using java.io.File.realpath (Showing top 7 results out of 315)

How to use
realpath
method
in
java.io.File