java.io.File.realpath java code examples

Common ways to obtain File

private void myMethod () {
 File f =String pathname;new File(pathname)
File.createTempFile("test", ".tmp")
String parent;String child;new File(parent, child)
Smart code suggestions by Tabnine
}

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

Running tasks concurrently on multiple threads
addToBackStack (FragmentTransaction)
getExternalFilesDir (Context)
setContentView (Activity)
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
MessageFormat (java.text)
Produces concatenated messages in language-neutral way. New code should probably use java.util.Forma
Queue (java.util)
A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
TreeSet (java.util)
TreeSet is an implementation of SortedSet. All optional operations (adding and removing) are support
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
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