# Java File I/O - Complete Guide for Lab 15
## Table of Contents
1. [Introduction to File I/O](#introduction-to-file-io)
2. [File Handling Classes](#file-handling-classes)
3. [Reading from Files](#reading-from-files)
4. [Writing to Files](#writing-to-files)
5. [Exception Handling](#exception-handling)
6. [String Manipulation](#string-manipulation)
7. [Complete Examples](#complete-examples)
8. [Common Patterns & Best Practices](#common-patterns--best-practices)
---
## Introduction to File I/O
File I/O (Input/Output) allows Java programs to read from and write to files on the disk. All file operations in Java use classes from the `java.io` package.
### Why File I/O?
- **Persistence**: Store data permanently
- **Data Exchange**: Share data between programs
- **Logging**: Keep records of program execution
- **Configuration**: Store settings and preferences
---
## File Handling Classes
### 1. FileWriter
**Purpose**: Write character data to files
**Syntax**:
```java
FileWriter fw = new FileWriter("filename.txt");
```
**Key Methods**:
```java
write(String str) // Write a string
write(int c) // Write a single character
close() // Close the stream
```
**Example**:
```java
FileWriter fw = new FileWriter("output.txt");
fw.write("Hello World");
fw.write('\n');
fw.close();
```
**Important Notes**:
- Creates a new file if it doesn't exist
- **Overwrites** existing content by default
- Must close the stream to ensure data is written
- Throws `IOException`
---
### 2. FileReader
**Purpose**: Read character data from files
**Syntax**:
```java
FileReader fr = new FileReader("filename.txt");
```
**Key Methods**:
```java
read() // Read a single character (returns int, -1 if end)
read(char[] cbuf) // Read into character array
close() // Close the stream
```
**Example**:
```java
FileReader fr = new FileReader("input.txt");
int ch;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}
fr.close();
```
**Important Notes**:
- Reads one character at a time
- Returns -1 when end of file is reached
- Cast int to char for display
- Throws `IOException`
---
### 3. BufferedWriter
**Purpose**: Write text efficiently with buffering
**Syntax**:
```java
BufferedWriter bw = new BufferedWriter(new FileWriter("file.txt"));
```
**Key Methods**:
```java
write(String str) // Write a string
newLine() // Write platform-specific line separator
close() // Close the stream
```
**Example**:
```java
BufferedWriter bw = new BufferedWriter(new FileWriter("data.txt"));
bw.write("First Line");
bw.newLine();
bw.write("Second Line");
bw.close();
```
**Advantages**:
- More efficient for large amounts of text
- Has `newLine()` method for platform-independent line breaks
- Buffers data to reduce disk I/O operations
---
### 4. BufferedReader
**Purpose**: Read text efficiently with buffering
**Syntax**:
```java
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
```
**Key Methods**:
```java
readLine() // Read a line of text (returns String, null if end)
read() // Read a single character
close() // Close the stream
```
**Example**:
```java
BufferedReader br = new BufferedReader(new FileReader("data.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
```
**Advantages**:
- Read entire lines at once
- Much faster than FileReader for text files
- Returns null at end of file
---
### 5. FileOutputStream
**Purpose**: Write raw byte data to files
**Syntax**:
```java
FileOutputStream fos = new FileOutputStream("file.bin");
```
**Key Methods**:
```java
write(int b) // Write a single byte
write(byte[] b) // Write byte array
close() // Close the stream
```
**Example**:
```java
FileOutputStream fos = new FileOutputStream("binary.dat");
fos.write(65); // Writes 'A'
fos.close();
```
---
### 6. FileInputStream
**Purpose**: Read raw byte data from files
**Syntax**:
```java
FileInputStream fis = new FileInputStream("file.bin");
```
**Key Methods**:
```java
read() // Read a single byte (returns int, -1 if end)
available() // Returns bytes available to read
close() // Close the stream
```
**Example**:
```java
FileInputStream fis = new FileInputStream("binary.dat");
int data;
while ((data = fis.read()) != -1) {
System.out.print((char) data);
}
fis.close();
```
---
### 7. DataOutputStream
**Purpose**: Write primitive data types to files
**Syntax**:
```java
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"));
```
**Key Methods**:
```java
writeInt(int v) // Write an integer
writeDouble(double v) // Write a double
writeBytes(String s) // Write string as bytes
writeUTF(String s) // Write string in UTF format
close() // Close the stream
```
**Example**:
```java
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"));
dos.writeInt(100);
dos.writeDouble(3.14);
dos.writeBytes("Hello");
dos.close();
```
---
### 8. DataInputStream
**Purpose**: Read primitive data types from files
**Syntax**:
```java
DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"));
```
**Key Methods**:
```java
readInt() // Read an integer
readDouble() // Read a double
readUTF() // Read a UTF string
available() // Check available bytes
close() // Close the stream
```
**Example**:
```java
DataInputStream dis = new DataInputStream(new FileInputStream("data.bin"));
int num = dis.readInt();
double value = dis.readDouble();
dis.close();
```
---
## Reading from Files
### Pattern 1: Reading Character by Character (FileReader)
```java
FileReader fr = new FileReader("input.txt");
int ch;
while ((ch = fr.read()) != -1) {
System.out.print((char) ch);
}
fr.close();
```
**When to Use**: Small files, character-level processing
---
### Pattern 2: Reading Line by Line (BufferedReader)
```java
BufferedReader br = new BufferedReader(new FileReader("input.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
```
**When to Use**: Text files, line-based processing (most common)
---
### Pattern 3: Reading Bytes (DataInputStream)
```java
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
StringBuilder sb = new StringBuilder();
while (dis.available() > 0) {
sb.append((char) dis.read());
}
dis.close();
String content = sb.toString();
```
**When to Use**: Binary data, byte-level control
---
### Pattern 4: Reading with StringBuilder
```java
BufferedReader br = new BufferedReader(new FileReader("data.txt"));
StringBuilder content = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
content.append(line).append("\n");
}
br.close();
String fullContent = content.toString();
```
**When to Use**: Need entire file content as a single string
---
## Writing to Files
### Pattern 1: Simple Text Writing (FileWriter)
```java
FileWriter fw = new FileWriter("output.txt");
fw.write("Line 1\n");
fw.write("Line 2\n");
fw.close();
```
**When to Use**: Simple, small text output
---
### Pattern 2: Efficient Text Writing (BufferedWriter)
```java
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"));
bw.write("First Line");
bw.newLine();
bw.write("Second Line");
bw.close();
```
**When to Use**: Multiple writes, better performance
---
### Pattern 3: Formatted Output
```java
FileWriter fw = new FileWriter("prices.txt");
double price = 99.99;
fw.write(String.format("%.2f", price)); // Writes "99.99"
fw.close();
```
**When to Use**: Decimal formatting, precise output format
---
### Pattern 4: Binary Data Writing (DataOutputStream)
```java
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.bin"));
dos.writeBytes("Hello World");
dos.close();
```
**When to Use**: Binary files, primitive type storage
---
## Exception Handling
### Why Exception Handling?
File operations can fail for many reasons:
- File doesn't exist
- No permission to read/write
- Disk is full
- File is locked by another program
### Method 1: Throws Declaration
```java
public void readFile(String filename) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(filename));
String line = br.readLine();
br.close();
}
```
**When to Use**: When the calling method should handle the exception
---
### Method 2: Try-Catch Block
```java
public void readFile(String filename) {
try {
BufferedReader br = new BufferedReader(new FileReader(filename));
String line = br.readLine();
br.close();
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
```
**When to Use**: When you want to handle the error in this method
---
### Method 3: Try-with-Resources (Best Practice - Java 7+)
```java
public void readFile(String filename) {
try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
String line = br.readLine();
// No need to close - automatically closed
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
```
**Advantages**:
- Automatically closes resources
- Cleaner code
- Prevents resource leaks
---
## String Manipulation
### 1. String Formatting
#### Format Decimals
```java
double value = 3.14159;
String formatted = String.format("%.2f", value); // "3.14"
```
**Format Specifiers**:
- `%d` - Integer
- `%f` - Float/Double
- `%.2f` - Float with 2 decimal places
- `%s` - String
- `%c` - Character
---
### 2. String Splitting
```java
String text = "Hello World Java";
String[] words = text.split("\\s+"); // Split by whitespace
// Result: ["Hello", "World", "Java"]
```
**Common Delimiters**:
- `"\\s+"` - One or more whitespace characters
- `","` - Comma
- `"\\."` - Period (dot)
- `"\\|"` - Pipe
---
### 3. String Methods
```java
String str = " Hello World ";
// Case conversion
str.toLowerCase() // " hello world "
str.toUpperCase() // " HELLO WORLD "
// Trimming
str.trim() // "Hello World"
// Checking content
str.contains("World") // true
str.startsWith("Hello") // false (has spaces)
str.endsWith("World") // false (has spaces)
// Finding
str.indexOf("World") // 8
str.indexOf("xyz") // -1 (not found)
// Checking empty
str.isEmpty() // false
str.trim().isEmpty() // false
"".isEmpty() // true
```
---
### 4. Character Array Conversion
```java
String text = "Hello";
// String to char array
char[] chars = text.toCharArray();
// Iterate through characters
for (char ch : chars) {
System.out.println(ch);
}
```
---
### 5. StringBuilder
```java
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString(); // "Hello World"
```
**When to Use**:
- Building strings in loops
- Concatenating many strings
- Better performance than string concatenation
---
### 6. Character Checking
```java
char ch = 'A';
// Check if vowel
if ("AEIOUaeiou".indexOf(ch) != -1) {
System.out.println("Vowel");
}
// Check if digit
if (Character.isDigit(ch)) {
System.out.println("Digit");
}
// Check if letter
if (Character.isLetter(ch)) {
System.out.println("Letter");
}
// Check if uppercase
if (Character.isUpperCase(ch)) {
System.out.println("Uppercase");
}
```
---
## Complete Examples
### Example 1: Copy File Content
```java
import java.io.*;
class FileCopy {
public void copyFile(String source, String destination) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(source));
BufferedWriter bw = new BufferedWriter(new FileWriter(destination));
String line;
while ((line = br.readLine()) != null) {
bw.write(line + "\n");
}
br.close();
bw.close();
}
public static void main(String[] args) {
FileCopy fc = new FileCopy();
try {
fc.copyFile("input.txt", "output.txt");
System.out.println("File copied successfully");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}
```
---
### Example 2: Count Words in File
```java
import java.io.*;
class WordCounter {
public int countWords(String filename) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(filename));
int count = 0;
String line;
while ((line = br.readLine()) != null) {
String[] words = line.trim().split("\\s+");
for (String word : words) {
if (!word.isEmpty()) {
count++;
}
}
}
br.close();
return count;
}
public static void main(String[] args) {
WordCounter wc = new WordCounter();
try {
int words = wc.countWords("text.txt");
System.out.println("Total words: " + words);
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}
```
---
### Example 3: Write and Read Formatted Data
```java
import java.io.*;
class StudentRecord {
private String name;
private int marks;
public void writeRecord(String filename, String name, int marks) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter(filename));
bw.write("Name: " + name + "\n");
bw.write("Marks: " + marks + "\n");
bw.close();
}
public void readRecord(String filename) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(filename));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();
}
public static void main(String[] args) {
StudentRecord sr = new StudentRecord();
try {
sr.writeRecord("student.txt", "John Doe", 95);
sr.readRecord("student.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
---
### Example 4: Sentiment Analysis
```java
import java.io.*;
class SentimentAnalyzer {
public void writeText(String text, String filename) throws IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream(filename));
dos.writeBytes(text);
dos.close();
}
public String analyzeSentiment(String filename) throws IOException {
DataInputStream dis = new DataInputStream(new FileInputStream(filename));
StringBuilder content = new StringBuilder();
while (dis.available() > 0) {
content.append((char) dis.read());
}
dis.close();
String text = content.toString().toLowerCase();
if (text.contains("happy") || text.contains("good") ||
text.contains("excellent") || text.contains("positive")) {
return "Positive";
} else if (text.contains("sad") || text.contains("bad") ||
text.contains("terrible") || text.contains("negative")) {
return "Negative";
} else {
return "Neutral";
}
}
public static void main(String[] args) {
SentimentAnalyzer sa = new SentimentAnalyzer();
try {
sa.writeText("I am happy today", "input.txt");
String sentiment = sa.analyzeSentiment("input.txt");
System.out.println("Sentiment: " + sentiment);
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
---
### Example 5: Character Encryption/Decryption
```java
import java.io.*;
class Encryption {
public String encrypt(String message) {
StringBuilder encrypted = new StringBuilder();
for (char ch : message.toCharArray()) {
encrypted.append((char)(ch + 1)); // Shift by 1
}
return encrypted.toString();
}
public String decrypt(String message) {
StringBuilder decrypted = new StringBuilder();
for (char ch : message.toCharArray()) {
decrypted.append((char)(ch - 1)); // Shift back by 1
}
return decrypted.toString();
}
public void saveToFile(String data, String filename) throws IOException {
FileWriter fw = new FileWriter(filename);
fw.write(data);
fw.close();
}
public String readFromFile(String filename) throws IOException {
BufferedReader br = new BufferedReader(new FileReader(filename));
StringBuilder content = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
content.append(line);
}
br.close();
return content.toString();
}
public static void main(String[] args) {
Encryption enc = new Encryption();
String message = "Hello";
try {
String encrypted = enc.encrypt(message);
System.out.println("Encrypted: " + encrypted);
enc.saveToFile(encrypted, "encrypted.txt");
String read = enc.readFromFile("encrypted.txt");
String decrypted = enc.decrypt(read);
System.out.println("Decrypted: " + decrypted);
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
---
### Example 6: Replace Vowels
```java
import java.io.*;
class VowelReplacer {
public String replaceVowels(String text, char consonant) {
StringBuilder result = new StringBuilder();
for (char ch : text.toCharArray()) {
if ("AEIOUaeiou".indexOf(ch) != -1) {
result.append(consonant);
} else {
result.append(ch);
}
}
return result.toString();
}
public void processFile(String input, String output, char consonant) throws IOException {
// Read from input file
BufferedReader br = new BufferedReader(new FileReader(input));
StringBuilder content = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
content.append(line);
}
br.close();
// Replace vowels
String modified = replaceVowels(content.toString(), consonant);
// Write to output file
FileWriter fw = new FileWriter(output);
fw.write(modified);
fw.close();
}
public static void main(String[] args) {
VowelReplacer vr = new VowelReplacer();
try {
vr.processFile("input.txt", "output.txt", 'x');
System.out.println("Vowels replaced successfully");
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
---
## Common Patterns & Best Practices
### 1. Always Close Streams
```java
// BAD - Stream might not close if exception occurs
FileWriter fw = new FileWriter("file.txt");
fw.write("data");
fw.close();
// GOOD - Using try-with-resources
try (FileWriter fw = new FileWriter("file.txt")) {
fw.write("data");
} catch (IOException e) {
e.printStackTrace();
}
```
---
### 2. Handle Exceptions Properly
```java
// Method signature declares exception
public void method() throws IOException {
// Calling code must handle
}
// Or handle locally
public void method() {
try {
// File operations
} catch (IOException e) {
e.printStackTrace(); // or log error
}
}
```
---
### 3. Use BufferedReader/Writer for Text
```java
// Inefficient
FileReader fr = new FileReader("file.txt");
// Efficient
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
```
---
### 4. Check for Empty Strings
```java
String[] words = line.trim().split("\\s+");
for (String word : words) {
if (!word.isEmpty()) { // Important check
count++;
}
}
```
---
### 5. Use StringBuilder for String Building
```java
// BAD - Creates many string objects
String result = "";
for (int i = 0; i < 1000; i++) {
result += "word ";
}
// GOOD - Efficient
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append("word ");
}
String result = sb.toString();
```
---
### 6. Proper File Paths
```java
// Windows
String path = "C:\\Users\\Documents\\file.txt";
// Or use forward slash (works on all platforms)
String path = "C:/Users/Documents/file.txt";
// Relative path
String path = "data/file.txt";
```
---
### 7. Reading Until End of File
```java
// For BufferedReader - check for null
while ((line = br.readLine()) != null) {
// Process line
}
// For FileReader/InputStream - check for -1
while ((ch = fr.read()) != -1) {
// Process character
}
// For DataInputStream - check available()
while (dis.available() > 0) {
// Read data
}
```
---
## Quick Reference Card
### Common File Operations
| Operation | Code |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Write text | `FileWriter fw = new FileWriter("file.txt");`
`fw.write("text");`
`fw.close();` |
| Read text | `BufferedReader br = new BufferedReader(new FileReader("file.txt"));`
`String line = br.readLine();`
`br.close();` |
| Copy file | Read from source, write to destination |
| Append to file | `FileWriter fw = new FileWriter("file.txt", true);` |
| Check file exists | `File f = new File("file.txt");`
`boolean exists = f.exists();` |
---
### Common String Operations
| Operation | Code |
| -------------- | ---------------------------------------- |
| Split string | `String[] parts = str.split("\\s+");` |
| Format decimal | `String.format("%.2f", value)` |
| Check vowel | `"AEIOUaeiou".indexOf(ch) != -1` |
| Convert case | `str.toLowerCase()`, `str.toUpperCase()` |
| Trim spaces | `str.trim()` |
| Check contains | `str.contains("substring")` |
---
## Tips for Assessment
1. **Always import java.io.\***
```java
import java.io.*;
```
2. **Remember to close streams** or use try-with-resources
3. **Handle IOException** with throws or try-catch
4. **Use correct read loop patterns**:
- `readLine() != null` for BufferedReader
- `read() != -1` for FileReader/InputStream
- `available() > 0` for DataInputStream
5. **Format output correctly**:
- Use `String.format()` for decimal places
- Use `\n` or `newLine()` for new lines
6. **String manipulation**:
- `split()` for word separation
- `trim()` to remove spaces
- `toLowerCase()/toUpperCase()` for case conversion
7. **Common mistakes to avoid**:
- Forgetting to close streams
- Not handling exceptions
- Not checking for empty strings after split
- Forgetting to cast `read()` result to char
---
## Summary
### Key Concepts Covered:
✅ File reading (FileReader, BufferedReader, DataInputStream)
✅ File writing (FileWriter, BufferedWriter, DataOutputStream)
✅ Exception handling (try-catch, throws)
✅ String manipulation (split, format, trim, contains)
✅ Character operations (vowel checking, encryption)
✅ File copying and processing
✅ Data analysis (word counting, sentiment analysis)
### Most Important Classes:
1. **BufferedReader** - Read text files line by line
2. **BufferedWriter** - Write text files efficiently
3. **FileReader** - Read characters
4. **FileWriter** - Write characters
5. **DataInputStream/DataOutputStream** - Read/write bytes
### Master These Patterns:
1. Read file line by line
2. Write formatted data to file
3. Copy file content
4. Process and transform text
5. Exception handling with file operations
---
**Good luck with your assessment! 🚀**
_Remember: Practice these patterns, understand the syntax, and always handle exceptions properly!_