An absolute path is a path that points to the same location in the file system, regardless of the current directory. The full path always starts from the root directory.
A relative path is a path relative to the current working directory.
The standard I/O classes in Java are in the java.io.* package. JDK 7 added a more modern way of working with threads called Java NIO or Java New IO, these classes are in the java.nio.* package. To work with archives, classes from the java.util.* package are used.
I/O wrapper classes are classes that add useful additional properties to existing streams.
Class examples: BufferedOutputStream, BufferedInputStrem, BufferedWriter , BufferedReader - buffer the stream and improve performance.
To read byte data (not strings), use the DataInputStream class. In this case, you must use the classes from the InputStream group.
The getBytes() method is provided in the String class to convert a string into an array of bytes suitable for putting into a ByteArrayInputStream. The resulting ByteArrayInputStream is an InputStream suitable for passing the DataInputStream.
When reading characters byte-by-byte from a formatted DataInputStream using the readByte() method, any value received will be considered valid, so the return value is not applicable to identify the end of the stream. Instead, you can use the available() method, which tells you how many characters are left.
The DataInputStream class allows you to read primitive data types from a stream through the DataInput interface, which defines methods that convert elementary values to a sequence of bytes. Such streams make it easy to store binary data in a file.
For this, classes are used that allow buffering the stream:
java.io.BufferedInputStream - buffered input stream. Constructors: BufferedInputStream(InputStream in), BufferedInputStream(InputStream in, int size).
java.io.BufferedOutputStream - buffered output stream. Constructors: BufferedOutputStream(OutputStream out), BufferedOutputStream(OutputStream out, int size).
java.io.BufferedReader - buffered input character stream. Constructors: BufferedReader(Reader r), BufferedReader(Reader in, int sz).
java.io.BufferedWriter - buffered output character stream. Constructors: BufferedWriter(Writer out), BufferedWriter(Writer out, int sz).
First of all, the PrintWriter class uses an improved way of working with UNICODE characters and a different output buffering mechanism.
In the PrintStream class, the output buffer was flushed whenever the print or println method was called. When using the PrintWriter class, you can disable automatically flushing buffers by doing it explicitly with the flush method.
The PrintWriter class provides two constructors that allow you to work with the output streams of the OutputStream class:
public PrintWriter(OutputStream out); - creates a stream without automatically flushing buffers.
public PrintWriter(OutputStream out, boolean autoFlush); - the way buffers are flushed when using the second constructor depends on the value of the autoFlush parameter. If it is true, automatic flushing of buffers is performed, and if it is false, it is not.
The set of implementations of the main print and println methods of the PrintWriter class is similar to the set of implementations of these methods of the PrintStream class.
Unlike most I/O classes, the File class does not work with streams, but directly with files. This class allows you to get information about the file: access rights, time and date of creation, directory path. And also to navigate through the hierarchies of subdirectories.
The java.io.File class can represent the name of a specific file, as well as the names of a group of files found in a directory. If the class represents a directory, then its list() method returns an array of strings with the names of all the files.
You can use one of the following constructors to create objects of the File class.
File(File dir, String name) - you specify object of class File (the directory where file is located) and file name are specified
File(String path) - specify the path to the file without specifying the file name
File(String dirPath, Sring name) - specifies the path to the file and the file name
File(URI url) - specifies the URI object describing the file
The delimiter symbol differs for different systems. You can pull it out from the property of the static field File.separator. For Windows it is "\".
The File class has a lot of methods, let's list some of them.
getAbsolutePath() - the absolute path of the file, starting from the system root. In Android, the root element is the slash character (/)
canRead() - verifies whether the file is available for reading
canWrite() - available for writing
exists() - file exists or not
getName() - returns the file name
getParent() - returns the name of the parent directory
getPath() - path
lastModified() - last modified date
isFile() - the object is a file, not a directory
isDirectory() - the object is a directory
isAbsolute() - returns true if the file has an absolute path
renameTo(File newPath) - Renames a file. The parameter specifies the name of the new file name. If the rename was unsuccessful, then false is returned.
delete() - deletes a file. You can also delete an empty directory
The FileFilter interface is used to check if a File object matches a certain condition. This interface contains a single boolean accept(File pathName) method. This method must be overridden and implemented.
DeflaterOutputStream, InflaterInputStream, ZipInputStream, ZipOutputStream, GZIPInputStream, GZIPOutputStream.
Serialization is the process of reading or writing an object. It is the process of saving the state of an object and reading that state. To implement serialization, you need to implement an interface - the Serializable marker interface. The reverse operation - translating bytes into an object, is called deserialization.
In order to exclude fields from the serializable stream, it is necessary to mark the field with the transient modifier.
Class properties marked with the transient modifier are not serialized. Typically, such fields store the intermediate state of the object, which, for example, is easier to calculate than to serialize and then deserialize. Another example of such a field is a reference to an instance of an object that does not require or cannot be serialized.
The private static final long serialVersionUID field contains the unique version identifier of the serialized class. It is calculated from the contents of the class - the fields, their declaration order, the methods, their declaration order. Accordingly, with any change in the class, this field will change its value.
This field is written to the stream when the class is serialized. By the way, this is perhaps the only known case when a static field is serialized.
The OutputStreamWriter is a bridge between the OutputStream class and the Writer class. Characters written to the stream are converted to bytes.
InputStreamReader - analogue for reading. Using the methods of the Reader class, bytes are read from the InputStream and then converted into characters.
In most cases, we do not define behavior manually, but rely on the standard implementation, and it is very inconvenient to constantly override some serialization methods + constantly monitor the addition of new fields, add them to methods. Well and specially for these purposes - there is Externalizable.
However, we know that you can change the default behavior of serialization by predefining and placing two methods in your class files:
private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;
Note that both methods are declared private as this ensures that the methods are not overridden or overloaded. The whole trick is that the virtual machine, when calling the corresponding method, automatically checks if they were declared in the object class. The virtual machine can call the private methods of your class at any time, but other objects cannot. This ensures the integrity of the class and the normal operation of the serialization protocol.
Instead of implementing the Serializable interface, you can implement the Externalizable interface, which contains two methods:
public void writeExternal(ObjectOutput out) throws IOException;
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
To create your own protocol, you just need to override these two methods. Unlike the other two serialization options, nothing is done automatically here. The protocol is completely in your hands. Although this is the most difficult method, it is also brings you the most controll over serialization process.
The problem is that after deserialization we will get another object. So serialization makes it possible to create a Singleton again, which is not what we want when we design singleton. Of course, you can forbid serializing Singletons, but this, in fact, is an avoidance of the problem, not a solution to it.
The solution is the following. The class defines a method with the following signature:
The access modifier can be private, protected, and default. The purpose of this method is to return a replacement object instead of the object on which it is called.