Understanding Programming Methodologies: A Comprehensive Guide Introduction Programming methodologies define structured approaches to writing code, improving efficiency, maintainability, and scalability. Different methodologies provide distinct ways of thinking about problem-solving, organizing logic, and structuring applications. This blog explores various programming methodologies, their advantages, drawbacks, applications, and best use cases. 1. Procedural Programming Procedural programming follows a step-by-step approach where code is structured as procedures or functions. Characteristics: Based on the concept of procedure calls. Follows a linear, top-down execution model. Uses variables, loops, and control structures. Languages: C, Pascal, Fortran Sample Code (C): #include <stdio.h> void greet() { printf("Hello, World!\n"); } int main() { greet(); return 0; } Applications: Embedded systems (e.g., firmware, microcontrollers) Operating systems (e.g., Li...
Input/Output Streams in Java
In Java, streams represent a sequence of data. Input streams are used for reading data from a source, while output streams are used for writing data to a destination.
Types of Streams:
1. Byte Streams:
- Operate on bytes.
- Suitable for binary data.
- `InputStream` and `OutputStream` are the abstract classes for byte streams.
2. Character Streams:
- Operate on characters, internally converting them to bytes.
- Suitable for text data.
- `Reader` and `Writer` are the abstract classes for character streams.
Commonly Used Byte Streams:
- `FileInputStream` and `FileOutputStream`: For reading/writing from/to files.
- `ByteArrayInputStream` and `ByteArrayOutputStream`: For reading/writing to byte arrays.
- `DataInputStream` and `DataOutputStream`: For reading/writing primitive data types.
- `ObjectInputStream` and `ObjectOutputStream`: For reading/writing Java objects.
Commonly Used Character Streams:
- `FileReader` and `FileWriter`: For reading/writing text files.
- `BufferedReader` and `BufferedWriter`: For reading/writing text with buffering for efficiency.
- `InputStreamReader` and `OutputStreamWriter`: For bridging byte and character streams.
Basic Usage Pattern:
1. Opening Streams:
- Create a stream object by passing the appropriate source or destination as a parameter to its constructor.
2. Reading/Writing Data:
- Use methods like `read()`, `write()`, `readLine()`, `writeLine()`, etc., to perform I/O operations.
3. Closing Streams:
- Always close streams after use to release system resources.
- Use `close()` method or utilize try-with-resources statement for automatic resource management.
Example:
import java.io.*;
public class StreamExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("input.txt");
FileOutputStream fos = new FileOutputStream("output.txt")) {
int byteRead;
while ((byteRead = fis.read()) != -1) {
fos.write(byteRead);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Comments
Post a Comment