congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
File.realpath
Code IndexAdd Tabnine to your IDE (free)

How to use
realpath
method
in
java.io.File

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

origin: robovm/robovm

/**
 * 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());
}
origin: MobiVM/robovm

/**
 * 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());
}
origin: com.mobidevelop.robovm/robovm-rt

/**
 * 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());
}
origin: com.gluonhq/robovm-rt

/**
 * 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());
}
origin: ibinti/bugvm

/**
 * 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());
}
origin: com.bugvm/bugvm-rt

/**
 * 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());
}
origin: FlexoVM/flexovm

/**
 * 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());
}
java.ioFilerealpath

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
  • isFile,
  • length,
  • toURI,
  • createTempFile,
  • createNewFile,
  • toPath,
  • mkdir,
  • lastModified,
  • toString,
  • getCanonicalPath

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
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now