Hello every I have a query for creating FILE using FILE CLASS & FILEOUTPUTSTREAM CLASS . I know using FILE CLASS we have to use method name createfile to create an specific file and when we are using FILEOUTPUTSTREAM CLASS then we pass string path or name with in the class initialization then that file created automatic. But Then What is Different between both the cases?
A File is an abstract path. It has no physical existence.
It is only when "using" that File that the underlying physical storage is actually hit.
A FileOutputStream will handle file existence test/creation/opening etc for you.
Note: if you use Java 7, ditch File and use Path instead.
The File class is just a handle for the file. The FileOutputStream is an OutputStream that you can write to: FileOutputStream JavaDoc.
You can think of them as touch myfile.txt vs. echo > myfile.txt
Related
I have a client-server model, wherein the client is filling a form, and the server saves the form data into a .csv file. Here is the code I'm using to write to the csv:
String fileName="responses.csv";
File f = new File(fileName);
PrintWriter toFile = new PrintWriter(new BufferedWriter(new FileWriter(f, true)));
toFile.println("test1,test2,\"test3,test4\"");//test code
toFile.close();
I have a Java Servlet (javax.servlet-API 3.1.0) and a Tester.java class in a package. Tester.java has a main() method in it, which executes the above code and then terminates.
When I run this code in the Tester, it works fine and the csv is written as expected.
However, in my Servlet, the file is not written. I do not see any Exception to indicate that I have an access issue. Since both .java files are in the same package, they can both access my csv file.
Note that my main() method terminates after file writing whereas my Servlet does not.
Why is my servlet not able to write to file ? Any guidance is earnestly appreciated. Thanks
Please check if the file created actually exists and what permissions you see. Try to save the csv file on a path where the user has write permission.
Also, if there is no error, print the absolute path for the file to see where it got written to.
It's possible to save class from URLClassLoader to normal file.class? and then decompile it?
I trying save it just as object using
Class<?> clazz = classLoader.loadClass("foo.Bar");
FileOutputStream sf = new FileOutputStream(f);
ObjectOutputStream s = new ObjectOutputStream(sf);
s.writeObject(clazz);
s.close();
Bu that don't work.
So... how to decompile it? I need get something like result of jd-gui, but using class from URLClassLoader.
You need to map the class name (e.g. "foo.Bar") to a resource path name (e.g. "/foo/Bar.class") and then use classLoader.getResourceAsStream to open a stream to read the bytecode file.
In theory, this can then be fed to a decompiler ... assuming that you have a decompiler that can read from an InputStream.
What you are doing at the moment fails because a Class object cannot be serialized.
Do a simple HTTP download, rather than URLClassLoader, to get the class into a file. Then decompile that.
(Writing an object to an ObjectOutputStream only saves the data in an instance of the object, and even that works only if the object has implemented Serializable. Not what you're looking for here.)
is there a way to open a directory stream in Java like in C? I need a FileDescriptor of an opened directory. Well, actually just the number of the fd.
I try to implement a checkpoint/restore functionality in Java with the help of CRIU link. To do this, I need to deploy a RPC call to the CRIU service. There I have to provide the integer value of the FD of an already opened directory, where the image files of the process will be stored.
Thank you in advance!
is there a way to open a directory stream in Java like in C?
No there isn't. Not without resorting to native code.
If you want to "read" a directory in (pure) Java, you can do it using one of the following:
File.list() - gives you the names of the directory entries as strings.
File.list(FilenameFilter) - ditto, but only directory entries that match are returned.
File.listFiles() - like list() but returning File objects.
etcetera
Files.newDirectoryStream(Path) gives you an iterator for the Path objects for the entries in a directory.
The last one could be "close" to what you are trying to achieve, but it does not entail application code getting hold of a file descriptor for a directory, or the application doing a low-level "read" on the directory.
You don't need FD in Java. All you need is a reference to that file which you can simply acquire using File file = new File("PathToYourFile");
To read/write you have Streams in Java. You can use
BufferedReader fileReader = new BufferedReader(new FileReader(new File("myFile.txt")));
PrintWriter fileWriter = new PrintWriter(new FileWriter(new File("myFile.txt")));
Even directory is a file. You can use isDirectory() on file object to check if it is a directory or a file.
private FileDescriptor openFile(String path)
throws FileNotFoundException, IOException {
File file = new File(path);
FileOutputStream fos = new FileOutputStream(file);
// remember th 'fos' reference somewhere for later closing it
fos.write((new Date() + " Beginning of process...").getBytes());
return fos.getFD();
}
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.
This question already has answers here:
How to read file from ZIP using InputStream?
(7 answers)
Closed 1 year ago.
How can I create new File (from java.io) in memory, not on the hard disk?
I am using the Java language. I don't want to save the file on the hard drive.
I'm faced with a bad API (java.util.jar.JarFile). It's expecting File file of String filename. I have no file (only byte[] content) and can create temporary file, but it's not beautiful solution. I need to validate the digest of a signed jar.
byte[] content = getContent();
File tempFile = File.createTempFile("tmp", ".tmp");
FileOutputStream fos = new FileOutputStream(tempFile);
fos.write(archiveContent);
JarFile jarFile = new JarFile(tempFile);
Manifest manifest = jarFile.getManifest();
Any examples of how to achieve getting manifest without creating a temporary file would be appreciated.
How can I create new File (from java.io) in memory , not in the hard disk?
Maybe you are confusing File and Stream:
A File is an abstract representation of file and directory pathnames. Using a File object, you can access the file metadata in a file system, and perform some operations on files on this filesystem, like delete or create the file. But the File class does not provide methods to read and write the file contents.
To read and write from a file, you are using a Stream object, like FileInputStream or FileOutputStream. These streams can be created from a File object and then be used to read from and write to the file.
You can create a stream based on a byte buffer which resides in memory, by using a ByteArrayInputStream and a ByteArrayOutputStream to read from and write to a byte buffer in a similar way you read and write from a file. The byte array contains the "File's" content. You do not need a File object then.
Both the File... and the ByteArray... streams inherit from java.io.OutputStream and java.io.InputStream, respectively, so that you can use the common superclass to hide whether you are reading from a file or from a byte array.
It is not possible to create a java.io.File that holds its content in (Java heap) memory *.
Instead, normally you would use a stream. To write to a stream, in memory, use:
OutputStream out = new ByteArrayOutputStream();
out.write(...);
But unfortunately, a stream can't be used as input for java.util.jar.JarFile, which as you mention can only use a File or a String containing the path to a valid JAR file. I believe using a temporary file like you currently do is the only option, unless you want to use a different API.
If you are okay using a different API, there is conveniently a class in the same package, named JarInputStream you can use. Simply wrap your archiveContent array in a ByteArrayInputStream, to read the contents of the JAR and extract the manifest:
try (JarInputStream stream = new JarInputStream(new ByteArrayInputStream(archiveContent))) {
Manifest manifest = stream.getManifest();
}
*) It's obviously possible to create a full file-system that resides in memory, like a RAM-disk, but that would still be "on disk" (and not in Java heap memory) as far as the Java process is concerned.
You could use an in-memory filesystem, such as Jimfs
Here's a usage example from their readme:
FileSystem fs = Jimfs.newFileSystem(Configuration.unix());
Path foo = fs.getPath("/foo");
Files.createDirectory(foo);
Path hello = foo.resolve("hello.txt"); // /foo/hello.txt
Files.write(hello, ImmutableList.of("hello world"), StandardCharsets.UTF_8);
I think temporary file can be another solution for that.
File tempFile = File.createTempFile(prefix, suffix, null);
FileOutputStream fos = new FileOutputStream(tempFile);
fos.write(byteArray);
There is a an answer about that here.