Object Oriented Programming Using JAVA

File I/O Classes Reading  1. File Class:    - Represents a file or directory path in the file system.    - Provides methods for file manipulation and querying file attributes.        File file = new File("example.txt");    if (file.exists()) {        System.out.println("File exists!");    } else {        System.out.println("File does not exist!");    } 2. FileInputStream:    - Reads raw bytes from a file input stream.    - Suitable for reading binary data from files.        try (FileInputStream fis = new FileInputStream("example.txt")) {        int byteRead;        while ((byteRead = fis.read()) != -1) {            System.out.print((char) byteRead);        }    } catch (IOException e) {        e.printStackTrace();    } 3. BufferedReader:    - Reads text from a character-input stream efficiently by buffering characters.        try (BufferedReader br = new BufferedReader(new FileReader("example.txt"))) {        String line;        while (

 Object streams in Java are used to serialize and deserialize objects, allowing them to be written to and read from streams. Here are some notes and examples on object streams: 1. Object Streams:    - Object streams allow for the serialization and deserialization of Java objects.    - They provide a convenient way to persist Java objects to files or transmit them over networks. 2. ObjectInputStream and ObjectOutputStream:    - `ObjectInputStream` and `ObjectOutputStream` are classes in Java used for reading and writing objects to streams.    - These classes wrap byte streams and provide methods like `readObject()` and `writeObject()`.    Example (Writing Objects to ObjectOutputStream):    import java.io.*;    public class ObjectOutputStreamExample {        public static void main(String[] args) throws IOException {            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("objects.ser"));            Person person = new Person("John", 30);      

Data Streams in Java with examples: 1. Data Streams:    - Data streams are used for reading and writing primitive data types and strings from and to a source.    - They are more efficient than byte streams when working with primitive data types. 2. DataInputStream and DataOutputStream:    - `DataInputStream` and `DataOutputStream` are classes in Java that provide methods for reading and writing primitive data types and strings.    - These classes wrap byte streams and provide methods like `readInt()`, `writeDouble()`, `readUTF()`, etc.    Example (Writing to a DataOutputStream):    import java.io.*;    public class DataOutputStreamExample {        public static void main(String[] args) throws IOException {            DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));            dos.writeInt(42);            dos.writeDouble(3.14);            dos.writeUTF("Hello, world!");            dos.close();        }    }    Example (Reading from a Data

 Here are some notes on scanning and formatting in Java I/O with examples: 1. Scanning (Input):    - Scanning involves reading input from different sources like the keyboard, files, or network connections.    - Java provides the `Scanner` class in the `java.util` package to facilitate scanning.    Example:    import java.util.Scanner;    public class ScannerExample {        public static void main(String[] args) {            Scanner scanner = new Scanner(System.in);            System.out.print("Enter your name: ");            String name = scanner.nextLine();            System.out.println("Hello, " + name + "!");            scanner.close();        }    } 2. Formatting (Output):    - Formatting is the process of presenting data in a specific way, such as aligning text, setting precision for floating-point numbers, etc.    - The `System.out.printf()` method is commonly used for formatted output in Java I/O.    Example:    public class FormattingExample {    

Buffered Streams in Java: Buffered streams are used to improve the performance of input/output operations by reducing the number of system calls. They achieve this by using an internal buffer to read from or write to the underlying input/output stream in larger chunks, rather than one byte or character at a time. Buffered Input Stream Classes: - `BufferedInputStream`: Provides buffering for input bytes, allowing the reading of data from an underlying input stream. - `BufferedReader`: Reads text from a character-input stream, buffering characters to provide efficient reading of characters, arrays, and lines. Buffered Output Stream Classes: - `BufferedOutputStream`: Provides buffering for output bytes, allowing the writing of data to an underlying output stream. - `BufferedWriter`: Writes text to a character-output stream, buffering characters to provide efficient writing of characters, arrays, and lines. Example: Reading from a File using BufferedReader: import java.io.BufferedReader; i

Character streams in Java are used for handling input and output of character data, making them suitable for text-based operations where character encoding matters. Unlike byte streams, which deal with raw binary data, character streams handle characters and automatically handle character encoding and decoding. Let's explore character streams with an example: Example: Reading and Writing Text Files Using Character Streams In this example, we'll create a program that reads the contents of a text file using a `FileReader` and writes them into another text file using a `FileWriter`. import java.io.*; public class CharacterStreamExample {     public static void main(String[] args) {         String sourceFile = "source.txt";         String destinationFile = "destination.txt";         try (FileReader reader = new FileReader(sourceFile);              FileWriter writer = new FileWriter(destinationFile)) {             int character;             while ((character = re

 Java Byte Streams Byte streams in Java are used to handle input and output of raw binary data. They are suitable for handling low-level data such as images, audio, and binary files. Let's dive into an example to illustrate how byte streams work: Example: Copying a File Using Byte Streams In this example, we'll create a program that reads the contents of a source file and writes them into a destination file using byte streams. import java.io.*; public class ByteStreamExample {     public static void main(String[] args) {         String sourceFile = "source.txt";         String destinationFile = "destination.txt";         try (FileInputStream fis = new FileInputStream(sourceFile);              FileOutputStream fos = new FileOutputStream(destinationFile)) {             int byteRead;             while ((byteRead = fis.read()) != -1) {                 fos.write(byteRead);             }             System.out.println("File copied successfully!");