Is it possible to change the filepath of the File class in java without creating a new instance?
File file = new File(System.getProperty("user.home")); <br>
System.out.println(file.getPath());
returns C:\Users\username
now I want to go to the parent directory. I thought I could use something like this
file.setPath(file.getParent());
but I have to use
file = new File(file.getParent());
any other way I can achieve the same? Or maybe I could create multiple instances, store them in an array and work with two objects (directories) at the same time?
From the javadocs:
Instances of the File class are immutable; that is, once created, the abstract pathname represented by a File object will never change.
So, no, you can't change a File instance. If you want a different value, you have to instantiate a new File.
Apparently you missed File.getParentFile():
file = file.getParentFile();
Related
In my TestClass I want to read the txt-file. I am always very confused how I should go about getting a reference to the txt-file though. The example I dug out of the internet suggested using a BufferedReader which requires a Path object to instantiate. I thought I'd create a File object and invoke it's .toPath(). But now how do I instantiate my File object? The least scary of its constructors require a string, but which string?
The easiest way to reference the file path within the scope of your project would be to use the System properties. Using the below value would return to you the users current working directory. Something like this would do the trick:
File file = new File (System.getProperty ("user.dir") + "/" + path_to_txt_file);
Depending on your system you may need to modify the delimiter.
Often times, I find myself creating two objects like these:
String pathString = "/foo/bar";
File path = new File(pathString);
Though variable naming is a fairly subjective issue, what's the most common naming convention for File objects and their corresponding absolute file path stored in a String?
I guess there is no naming convention. I would either take a look at the constructor argument of File and name it after that, e.g.
String pathname = "/foo/bar";
File file = new File(pathname);
Normally the file has a meaning in your application. So I would choose a name that describes it. E.g.
String errorLogFilepath = "/var/log/error.log";
File errorLogFile = new File(errorLogFilepath);
Do you need to idependently identify the path?
If not, Id suggest just using:
File path = new File("/foo/bar");
Similarly, pass around File objects, not string paths.
If you are not reusing this path for further reference in the code , suggest you to initialize the file by passing an arguement. eg
File file = new File("/foo/bar");
This will prevent the creation of an extra string variable.
I always use double backslash and I've never have problem with that:
File outputfile = new File("c:\\Selenium\\workspace\\....\\input.txt");
I want to create a temporary file (that goes away when the application closes) with a specific name. I'm using this code:
f = File.createTempFile("tmp", ".txt", new File("D:/"));
This creates something like D:\tmp4501156806082176909.txt. I want just D:\tmp.txt. How can I do this?
In this case, don't use createTempFile. The point of createTempFile is to generate the "garbage" name in order to avoid name colisions.
You should use File.createNewFile() or simply write to the file. Whichever is more appropriate for your use case. You can then call File.deleteOnExit() to get the VM to look after cleaning up the file.
If you want to create just tmp.txt, then just create the file using createNewFile(), instead of createTempFile(). createTempFile is used to create temporary files that should not have the same name when created over and over.
Also have a look at this post which shows a very simple way to create files.
Taken the post mentioned above:
String path = "C:"+File.separator+"hello"+File.separator+"hi.txt";
//(use relative path for Unix systems)
File f = new File(path);
//(works for both Windows and Linux)
f.mkdirs();
f.createNewFile();
try regex
fileName = fileName.replaceAll("\\d", "");
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.