What's the difference between getPath(), getAbsolutePath(), and getCanonicalPath() in Java?

Question

And when do I use each one?

Thanks

Edit: I did read the documentation but I was hoping to get a shorter / simpler explanation.

Answer 1

Have you checked out the Java API docs. They document each class and the methods they provide.

Answer 2

In short:

• getPath() gets the path string that the File object was constructed with, and it may be relative current directory.
• getAbsolutePath() gets the path string after resolving it against the current directory if it's relative, resulting in a fully qualified path.
• getCanonicalPath() gets the path string after resolving any relative path against current directory, and removes any relative pathing (. and ..), and any file system links to return a path which the file system considers the canonical means to reference the file system object to which it points.

Also, each of this has a File equivalent which returns the corresponding File object.

Answer 3

Consider these filenames:

C:\temp\file.txt" - this is a path, an absolute path, a canonical path

.\file.txt This is a path, It's not an absolute path nor canonical path.

C:\temp\myapp\bin\..\\..\file.txt This is a path, and an absolute path, it's not a canonical path

Canonical path is always an absolute path.

Converting from a path to a canonical path makes it absolute (usually tack on the current working directory so e.g. ./file.txt becomes c:/temp/file.txt). The canonical path of a file just "purifies" the path, removing and resolving stuff like ..\ and resolving symlinks(on unixes)

Answer 4

The best way I have found to get a feel for things like this is to try them out:

import java.io.File;
public class PathTesting {
 public static void main(String [] args) {
  File f = new File("test/.././file.txt");
  System.out.println(f.getPath());
  System.out.println(f.getAbsolutePath());
  try {
   System.out.println(f.getCanonicalPath());
  }
  catch(Exception e) {}
 }
}

Your output will be something like:

test\..\.\file.txt
C:\projects\sandbox\trunk\test\..\.\file.txt
C:\projects\sandbox\trunk\file.txt

So, getPath() gives you the path based on the File object, which may or may not be relative; getAbsolutePath() gives you an absolute path to the file; and getCanonicalPath() gives you the unique absolute path to the file. Notice that there are a huge number of absolute paths that point to the same file, but only one canonical path.

When to use each? Depends on what you're trying to accomplish, but if you were trying to see if two Files are pointing at the same file on disk, you could compare their canonical paths. Just one example.

Answer 5

The big thing to get your head around is that the File class tries to represent a view of what Sun like to call "hierarchical pathnames" (basically a path like "c:/foo.txt" or /usr/muggins"). This is why you create files in terms of paths. The operations you are describing are all operations upon this "pathname".

• getPath() fetches the path that the File was created with ("../foo.txt")
• getAbsolutePath() fetches the path that the File was created with, but includes information about the current directory if the path is relative ("/usr/bobstuff/../foo.txt")
• getCanonicalPath() attempts to fetch a unique representation of the absolute path to the file. This eliminates indirection from ".." and "." references ("/usr/foo.txt").

Note I say attempts - in forming a Canonical Path, the VM can throw an IOException. This usually occurs because it is performing some filesystem operations, any one of which could fail.

Answer 6

getPath() returns the path used to create the File object. This return value is not changed based on the location it is run (results below are for windows, separators are obviously different elsewhere)

File f1 = new File("/some/path");
String path = f1.getPath(); // will return "\some\path"

File dir = new File("/basedir");
File f2 = new File(dir, "/some/path");
path = f2.getPath(); // will return "\basedir\some\path"

File f3 = new File("./some/path");
path = f3.getPath(); // will return ".\some\path"

getAbsolutePath() will resolve the path based on the execution location or drive. So if run from c:\test:

path = f1.getAbsolutePath(); // will return "c:\some\path"
path = f2.getAbsolutePath(); // will return "c:\basedir\some\path"
path = f3.getAbsolutePath(); // will return "c:\test\.\basedir\some\path"

getCanonicalPath() is system dependent. It will resolve the unique location the path represents. So if you have any "."s in the path they will typically be removed.

As to when to use them. It depends on what you are trying to achieve. getFile() is useful for portability. getAbsolutePath() is useful to find the file system location, and getCanonicalPath() is particularly useful to check if two files are the same.