Serialisation added.

Signed-off-by: Someshdiwan <[email protected]>

Author: Someshdiwan

Section23JavaIOStreams/Serialisation Storing Data in a File/src/IMP.txt

@@ -0,0 +1,29 @@
+InputStreamReader is commonly used to specify character encoding when reading text files.
+
+It acts as a bridge between byte streams and character streams, allowing you to read characters from a byte stream
+(like FileInputStream) using a specified character encoding.
+
+Key points about character encoding in Java I/O:
+1. FileReader uses the default character encoding of the system.
+2. InputStreamReader allows specifying a custom character encoding.
+3. It's important to use the correct encoding to avoid data corruption.
+4. Common encodings include UTF-8, UTF-16, ISO-8859-1, etc.
+
+Example usage:
+```java
+try (FileInputStream fis = new FileInputStream("file.txt");
+     InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
+     BufferedReader br = new BufferedReader(isr)) {
+
+    String line;
+    while ((line = br.readLine()) != null) {
+        System.out.println(line);
+    }
+} catch (IOException e) {
+    e.printStackTrace();
+}
+```
+
+In this example, InputStreamReader is used to read the file with UTF-8 encoding.
+This approach is more flexible than using FileReader, as it allows you to specify the encoding explicitly,
+ensuring that the file is read correctly regardless of the system's default encoding.

Section23JavaIOStreams/Serialisation Storing Data in a File/src/Serialisation.txt

@@ -0,0 +1,44 @@
+Key points about serialization:
+
+1. Serialization is the process of converting an object into a byte stream.
+2. Deserialization is the reverse process of creating an object from a byte stream.
+3. The Serializable interface is in the java.io package.
+4. Fields marked as transient are not serialized.
+5. Static fields are not serialized as they belong to the class, not the object.
+
+The method canRead() of the File class is used to check if a file is readable.
+
+This method returns a boolean value indicating whether the application can read the file denoted by the File object.
+
+Key points about file permissions in Java:
+1. canRead(): Checks if the file is readable.
+2. canWrite(): Checks if the file is writable.
+3. canExecute(): Checks if the file is executable.
+4. setReadable(), setWritable(), setExecutable(): Methods to change file permissions.
+
+Example usage:
+```java
+File file = new File("example.txt");
+
+if (file.canRead()) {
+    System.out.println("File is readable");
+} else {
+    System.out.println("File is not readable");
+}
+
+if (file.canWrite()) {
+    System.out.println("File is writable");
+} else {
+    System.out.println("File is not writable");
+}
+
+// Change permissions
+file.setWritable(true);
+file.setReadable(true, false); // true for all users, false for owner only
+```
+
+It's important to note that these methods work within the constraints of the underlying operating system
+and the Java Security Manager.
+
+The actual ability to read, write, or execute a file may depend on factors beyond just the file permissions,
+such as overall system security policies.