I was unable to understand the following file constructors.
public File(String parent, String child) and
public File(File parent, String child)
What do the parameters parent and child mean for the file? When can I use these? I have done few programs related to file but I have never used these. I usually use
public File(String pathname)
I have read Javadoc but I could not figure out when and how to use these constructors. Could someone please explain and give examples.
Explanation
The parent parameter is the parent directory of the child file name or relative file path.
Where parent is a File instance, it is a directory file. Where parent is a String, it's simply that directory in pathname terms.
Examples
Consider the following partial file system:
Documents
Homework
Classwork
Tests
Rather than declaring each new file with "Documents\Subdir", you can declare the Documents directory as a file, and use it as the parent File of the other File instances, like so:
File documents = new File("Documents");
File tests = new File("Documents/Tests"); // new File(String);
File homework = new File(documents, "Homework"); // new File(File, String)
File classwork = new File("Documents", "Classwork"); // new File(String, String)
Real-world application
In my experience, I've used applications that provide an API containing a method that returns the directory file in which third-party "plugins" are allowed to save/read files. Without the File(File, String) constructor, I would need to convert the directory file into an absolute path and append my target file to it.
In the following example, Environment.getProgramDirectory() returns the directory file in which permissions are granted.
File settingsFile = new File(Environment.getProgramDirectory(), "settings.txt");
Let's explain with some examples:
Assuming that you have the following structure:
/dir1
dir11
The constructor that you usually use new File("/dir1/dir11") is equivalent to
new File("/dir1", "dir11") (constructor taking 2 String as arguments)
and also equivalent to
new File(new File("/dir1"), "dir11") (constructor using a File as first argument).
"The parent abstract pathname is taken to denote a directory, and the child pathname string is taken to denote either a directory or a file. " As specified on the API
Parent will point to the Directory
Child will be its Contents..
Related
Is any difference? First solution has "new" and second hasn't. I see only this difference.
You should always use new File in this case.
(Also your second possibility will not work the way you use it here).
There are other cases where you for example only have a Path object and you'd like to convert it into a File. Then you would use the toFile method on the Path-Object to get a File back.
In your case you access the File, convert it into a Path and then back into a File, which isn't necessary at all.
For example if you have a Path and want the file from it:
//existing Path object
void receivePath(Path path) {
File = path.toFile();
}
What is the difference between the following two methods for creating a file?
new File(System.getProperty("user.dir"));
new File("");
Java identifies the first one as a directory, and the second one's neither a file nor a directory! Why is that the case?
Code:
public class MainClass {
public static void main(String[] args) throws Exception {
System.out.println("File Created with CurrentDir taken From System Props");
File f1 = new File(System.getProperty("user.dir"));
System.out.println("Absolute Path: " + f1.getAbsolutePath());
System.out.println("isDirectory: " + f1.isDirectory());
System.out.println("isFile: " + f1.isFile());
System.out.println();
System.out.println("File Created with Empty String Path");
File f2 = new File("");
System.out.println("Absolute Path: " + f2.getAbsolutePath());
System.out.println("isdirectory: " + f2.isDirectory());
System.out.println("isFile: " + f2.isFile());
}
}
Output:
File Created with CurrentDir taken From System Props
Absolute Path: D:\Java Workspace\my_Workspace\JavaTest
isDirectory: true
isFile: false
File Created with Empty String Path
Absolute Path: D:\Java Workspace\my_Workspace\JavaTest
isdirectory: false
isFile: false
Explanation
It may seem a little non-intuitive but actually that's just how the class is supposed to work according to its documentation. It's called empty abstract pathname in the documentation:
The empty abstract pathname has no prefix and an empty name sequence.
And from your constructor File#File(String):
Creates a new File instance by converting the given pathname string into an abstract pathname. If the given string is the empty string, then the result is the empty abstract pathname.
So the File class actually interprets the empty name as actual name. When you test File#isDirectory() or File#isFile() it thus checks if there exists a file or directory like
D:\Java Workspace\iTAW_Workspace\JavaTest\<empty>
Note the <empty> which I wrote to indicate that it actually searches for a file here with the empty name. Obviously such a file can not exist, thus the result will always be false. So again, it does not check
D:\Java Workspace\iTAW_Workspace\JavaTest\
but rather the empty file in this directory, which does not exist.
Unfortunately you don't see this when using the File#toAbsolutePath() method as there is no representation for an empty name.
NIO
Note that the class File and everything related to it is outdated. Nowadays file IO is done using NIO revolving around Files, Paths and Path. This API is much more cleaner and more intuitive. It will also work as intended on your current example:
Files.isDirectory(Paths.get("")); // true
Take a look at the documentation for more.
Creating a file with empty string results to creating a File instance which actually does not exist and its absolute pathname is "empty abstract pathname".
-> That's why the second one's neither a file nor a directory for you.
The reason behind that, a maybe little bit confusing output for you, is definition located in javadocs:
If this abstract pathname is the empty abstract pathname then the
pathname string of the current user directory, which is named by the
system property user.dir, is returned.
You can find more about this topic here
https://docs.oracle.com/javase/6/docs/api/java/io/File.html
You need to make the difference between the Java object File and a file actually present on your computer.
In the first case : new File(System.getProperty("user.dir")). You create a Java object File and give him a path : System.getProperty("user.dir"). Later when you call the function .getAbsolutePath() it returns you the path you gave. Then when you call .isDirectory() it tells you true because there is a directory corresponding to this Java object File.
In the second case, new File("") it creates a Java object File and you give it a path : "". Since the path given is not absolute, the system will resolve it as a relative from the user.dir path.
from documentation
A pathname, whether abstract or in string form, may be either absolute or relative. An absolute pathname is complete in that no other information is required in order to locate the file that it denotes. A relative pathname, in contrast, must be interpreted in terms of information taken from some other pathname. By default the classes in the java.io package always resolve relative pathnames against the current user directory. This directory is named by the system property user.dir, and is typically the directory in which the Java virtual machine was invoked.
Later when you call the function .getAbsolutePath() it returns you the path you gave, so the path to user dir + empty string : D:\Java Workspace\iTAW_Workspace\JavaTest\<empty>. Then when you call .isDirectory() it tells you false because there is no directory corresponding to this path. (same reason for isFile())
new File("") creates new file with relative (empty) path. As this file doesn't exist both isDirectory() and isFile() return false (corresponds to javadoc).
From javadoc
boolean java.io.File.isDirectory()
...
Returns: true if and only if
the file denoted by this abstract pathname exists and is a directory;
false otherwise
The same is true for isFile(). and as long as your file doesn't exist both methods return false.
I need to copy a File from A to B but keep the directory structure.
for example
C:\folder\second folder\myFile.txt
to
C:\new folder\my second folder\myFile.txt
so that if I the new destination does not exists it will get created
I have tried this example but it copies the whole directory not just the file I specified.
Make use of the File.mkdirs() function: Creates the directory named by this abstract pathname, including any necessary but nonexistent parent directories. Note that if this operation fails it may have succeeded in creating some of the necessary parent directories.
Prior to reading and writing the file, you can check whither the file path exists, if not then create it. For example:
String s = "c:\\A Dir\\B Dir\\myFile.txt";
File f = new File(s);
if(!f.getParentFile().exists())
f.getParentFile().mkdirs(); // create the parent directory "c:\\A Dir\\B Dir\\"
I have this very basic question.
Does File file = new File("fileName"); actually create a file if one does not exist?
What happens if the file already exists in that location?
Are there any good tutorials you can point me to so I can read more about it?
No it does not. The File object represents an abstract notion of a file, which may exist, but doesn't need to. Note that the File object can also point to a directory (which may or may not exist).
Usually you can find out information about java in the api
http://docs.oracle.com/javase/7/docs/api/java/io/File.html
No, if you want to create an empty file, use createNewFile
File myFile = new File("test.txt");
myFile.createNewFile();
No, calling the objects constructor simply creates an instance of the File-Class.
Read the documentation:
File(File parent, String child):
Creates a new File instance from a parent abstract pathname and a child pathname string.
The call of the createNewFile()- Method writes the file to disk.
Atomically creates a new, empty file named by this abstract pathname
if and only if a file with this name does not yet exist.
You can simply check it by creating a File-object with a non existing file path and calling the File.exists(); method.
if (!file.exists()) {
//File does not exist
}
The Java.iO.File document says the following words about its constructor which takes the pathname:
public File(String pathname)
Creates a new File instance by converting the given pathname string
into an abstract pathname. If the given string is the empty string,
then the result is the empty abstract pathname.
But what if the pathname points to a file which is already existing?
File file = new File(PATH_TO_AN_EXISTING_FILE);
Does the above file instance represent a fresh new file (with the existing one be deleted?) Or does it represent the existing file ?
What the documentation says is that it will create a new File instance. This mean it will create a new instance in memory of the File class.
This object will point to a file on you file system. However, if the file exists, it will not create a new file.
I think the documentation is a little confusing: creating a new File object in Java does not mean creation of a new file in your file system. The File object is merely an abstract representation of file and directory pathname, it may or may not represent a real file on disk or on a network storage.
It is more or less equivalent to a String representing an address of something: when you write
String str = "1600 Pennsylvania Ave NW, Washington, DC 20500";
you create a string with an address of an existing building. There is no other connection between the string str that you created and The White House that happens to be located at that address.
The only difference between a File created with an existing path name and a file created with a non-existent path name is that the call of exists() on the former will return true, while the same call on the later would return false.
A File is not directly linked to an actual file on the file system. If the file exists, it will point to that file. If the file doesn't exist, it will not create it. exist() will return false.
This is a very confusingly named class.
A File object represents a file path, not an actual file. So when you create a File object you do not change anything on the filing system. Conceptually, it's no different to a String.
In java.nio, the class has been renamed to (the much more intuitive) Path.
The java.io.File class represents a path on some file system. It is not directly bound to a file. You are not opening a file when you create a File instance.
A File object is merely an object on the heap. Yes, it does have fields and methods that imply that this object represents a real file (or a directory: see the ambiguity?).
You can create File objects for files/directories that do not exist: nothing will happen to the file system; the File instances will be created. After all, a File is just a descriptor.
Furthermore, you can create several File objects with different paths (esp. when one is absolute and others are relative from different parent paths), but they will all point to the same file/directory when they are actually evaluated (by opening a file with In/OutputStream, Reader/Writer; when checking with exists() or creating: createFile(), createDirectory().
File f=new File("C://Existing_file")
above line indicates already existed file not the new one to be created file.
File class instance always refers to IO operations and also it always refers to already consisted file
By creating new instance
File f= new File("ABC.txt");
This new object of file will point to a file named ABC.txt in your system, if present. If the ABC.txt file is not there, then the file object simply does not point to any file.
When a file is stored in a computer. The information related to the file is also stored( you can check it in the properties by right clicking on file). These are those information that is about the file.
So the File class object does nothing except represents the information about the file.
The File class object only provides you with information about the file and the same is stated in its definition.