Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Buffered Streams in Java — BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, performance benefits, line-by-line reading, and real-world file processing.
What are Buffered Streams?
Buffered streams add a memory buffer (internal array) between your program and the physical I/O device. Instead of making a system call for every byte/character, data is read or written in bulk chunks.
Without Buffer
Program ←→ [1 byte] ←→ Disk (thousands of slow system calls)
With Buffer
Program ←→ [8192 bytes buffer] ←→ Disk (few fast bulk reads)
Why Buffering Matters
Every disk read/write involves:
- System call overhead (user mode → kernel mode transition)
- Disk seek time (for HDDs)
- Transfer time
A single system call for 8KB costs almost the same as one for 1 byte. So reading 8192 bytes at once is ~8000× more efficient than reading 1 byte at a time.
The Four Buffered Stream Classes
| Class | Wraps | Purpose |
|---|---|---|
BufferedInputStream | InputStream | Buffered byte reading |
BufferedOutputStream | OutputStream | Buffered byte writing |
BufferedReader | Reader | Buffered character reading + readLine() |
BufferedWriter | Writer | Buffered character writing + newLine() |
BufferedReader — Line-by-Line Text Reading
The most commonly used buffered stream. Provides the essential readLine() method:
Example
import java.io.*;
public class BufferedReaderExample {
public static void main(String[] args) throws IOException {
// Create a test file
try (PrintWriter pw = new PrintWriter(new FileWriter("data.txt"))) {
pw.println("Line 1: Java is a programming language");
pw.println("Line 2: It was created by James Gosling");
pw.println("Line 3: Released in 1995");
pw.println("Line 4: Write once, run anywhere");
pw.println("Line 5: Over 3 billion devices run Java");
}
System.out.println("=== BufferedReader Demo ===\n");
// Method 1: readLine() — most common usage
System.out.println("--- Line by line (readLine) ---");
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
String line;
int lineNum = 1;
while ((line = reader.readLine()) != null) { // null = EOF
System.out.printf("%d: %s%n", lineNum++, line);
}
}
// Method 2: read() — single character
System.out.println("\n--- Character by character ---");
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
System.out.print("First 20 chars: ");
for (int i = 0; i < 20; i++) {
int c = reader.read();
if (c == -1) break;
System.out.print((char) c);
}
System.out.println();
}
// Method 3: read(char[]) — into buffer
System.out.println("\n--- Into char buffer ---");
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
char[] buffer = new char[50];
int charsRead = reader.read(buffer);
System.out.println("Read " + charsRead + " chars: " +
new String(buffer, 0, charsRead).replace("\n", "\\n"));
}
// Method 4: skip() and mark/reset
System.out.println("\n--- skip() and mark/reset ---");
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
reader.skip(8); // Skip "Line 1: "
String rest = reader.readLine();
System.out.println("After skipping 8: " + rest);
// mark and reset (BufferedReader supports this!)
reader.mark(1000); // Mark current position (readAheadLimit)
String line2 = reader.readLine();
System.out.println("Read line 2: " + line2);
reader.reset(); // Go back to mark
String line2Again = reader.readLine();
System.out.println("Read line 2 again: " + line2Again);
}
// Method 5: Java 8+ lines() stream
System.out.println("\n--- Java 8 Stream API ---");
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
reader.lines()
.filter(l -> l.contains("Java"))
.map(String::toUpperCase)
.forEach(System.out::println);
}
new File("data.txt").delete();
}
}
Output:
| 1 | Line 1: Java is a programming language |
| 2 | Line 2: It was created by James Gosling |
| 3 | Line 3: Released in 1995 |
| 4 | Line 4: Write once, run anywhere |
| 5 | Line 5: Over 3 billion devices run Java |
| First 20 chars | Line 1: Java is a pr |
| Read 50 chars | Line 1: Java is a programming language\nLine 2: It |
| After skipping 8 | Java is a programming language |
| Read line 2 | Line 2: It was created by James Gosling |
| Read line 2 again | Line 2: It was created by James Gosling |
| LINE 1 | JAVA IS A PROGRAMMING LANGUAGE |
| LINE 5 | OVER 3 BILLION DEVICES RUN JAVA |
BufferedWriter — Efficient Text Writing
java example
import java.io.*;
public class BufferedWriterExample {
public static void main(String[] args) throws IOException {
System.out.println("=== BufferedWriter Demo ===\n");
// Basic usage with newLine()
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("First line of text");
writer.newLine(); // Platform-independent line separator!
writer.write("Second line");
writer.newLine();
writer.write("Third line");
writer.newLine();
// Write partial strings
writer.write("Hello, World!", 0, 5); // Only "Hello"
writer.newLine();
// Write char array
char[] data = "BufferedWriter is fast!".toCharArray();
writer.write(data);
writer.newLine();
System.out.println("✓ File written with BufferedWriter");
}
// Verify by reading
try (BufferedReader reader = new BufferedReader(new FileReader("output.txt"))) {
System.out.println("\nFile contents:");
reader.lines().forEach(line -> System.out.println(" " + line));
}
new File("output.txt").delete();
}
}Output:
Example
=== BufferedWriter Demo ===
✓ File written with BufferedWriter
File contents:
First line of text
Second line
Third line
Hello
BufferedWriter is fast!
BufferedInputStream & BufferedOutputStream
Example
import java.io.*;
public class BufferedByteStreams {
public static void main(String[] args) throws IOException {
System.out.println("=== Buffered Byte Streams ===\n");
// Write with BufferedOutputStream
try (BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("binary.dat"), 4096)) { // 4KB buffer
// Write 100,000 bytes
for (int i = 0; i < 100_000; i++) {
bos.write(i % 256);
}
// flush() is called automatically by close()
System.out.println("✓ Written 100,000 bytes with buffer");
}
// Read with BufferedInputStream
try (BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("binary.dat"), 4096)) {
int byteCount = 0;
int sum = 0;
int b;
while ((b = bis.read()) != -1) {
byteCount++;
sum += b;
}
System.out.println("✓ Read " + byteCount + " bytes");
System.out.println(" Sum of all byte values: " + sum);
}
new File("binary.dat").delete();
}
}
Performance Comparison
Example
import java.io.*;
public class PerformanceComparison {
static void createTestFile(String path, int sizeInMB) throws IOException {
try (FileOutputStream fos = new FileOutputStream(path)) {
byte[] chunk = new byte[1024];
for (int i = 0; i < sizeInMB * 1024; i++) {
fos.write(chunk);
}
}
}
public static void main(String[] args) throws IOException {
String testFile = "testfile.dat";
createTestFile(testFile, 5); // Create 5MB file
System.out.println("Test file: 5 MB\n");
// Test 1: Unbuffered byte-by-byte
long start = System.currentTimeMillis();
try (FileInputStream fis = new FileInputStream(testFile)) {
while (fis.read() != -1) { }
}
long unbufferedTime = System.currentTimeMillis() - start;
// Test 2: BufferedInputStream byte-by-byte
start = System.currentTimeMillis();
try (BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(testFile))) {
while (bis.read() != -1) { }
}
long bufferedTime = System.currentTimeMillis() - start;
// Test 3: Manual buffer
start = System.currentTimeMillis();
try (FileInputStream fis = new FileInputStream(testFile)) {
byte[] buffer = new byte[8192];
while (fis.read(buffer) != -1) { }
}
long manualBufferTime = System.currentTimeMillis() - start;
// Results
System.out.println("=== Performance Results ===");
System.out.printf("Unbuffered (byte-by-byte): %5d ms%n", unbufferedTime);
System.out.printf("BufferedInputStream: %5d ms%n", bufferedTime);
System.out.printf("Manual 8KB buffer: %5d ms%n", manualBufferTime);
System.out.printf("%nBuffered is ~%dx faster than unbuffered%n",
unbufferedTime / Math.max(bufferedTime, 1));
new File(testFile).delete();
}
}
Output (approximate):
| Test file | 5 MB |
| Unbuffered (byte-by-byte) | 4523 ms |
| BufferedInputStream | 38 ms |
| Manual 8KB buffer | 12 ms |
Custom Buffer Sizes
java example
import java.io.*;
public class CustomBufferSize {
public static void main(String[] args) throws IOException {
// Default buffer size is 8192 (8KB)
BufferedReader defaultBR = new BufferedReader(new FileReader("test.txt"));
// Custom buffer sizes
BufferedReader smallBR = new BufferedReader(new FileReader("test.txt"), 256);
BufferedReader largeBR = new BufferedReader(new FileReader("test.txt"), 65536);
// When to use different sizes:
System.out.println("Buffer Size Guidelines:");
System.out.println(" 256 bytes - Memory-constrained environments");
System.out.println(" 8192 bytes - Default (good for most cases)");
System.out.println(" 32KB-64KB - Large file processing");
System.out.println(" 1MB+ - Rarely useful (diminishing returns)");
System.out.println();
System.out.println("Rule of thumb: Default 8KB is fine for 99% of cases");
}
}Real-World Example: Log File Analyzer
Example
import java.io.*;
import java.util.*;
public class LogAnalyzer {
public static void main(String[] args) throws IOException {
// Create sample log file
createSampleLog("app.log");
System.out.println("=== Log File Analyzer ===\n");
Map<String, Integer> levelCounts = new LinkedHashMap<>();
Map<String, Integer> hourCounts = new TreeMap<>();
List<String> errors = new ArrayList<>();
int totalLines = 0;
try (BufferedReader reader = new BufferedReader(new FileReader("app.log"))) {
String line;
while ((line = reader.readLine()) != null) {
totalLines++;
// Count log levels
for (String level : new String[]{"INFO", "WARN", "ERROR", "DEBUG"}) {
if (line.contains("[" + level + "]")) {
levelCounts.merge(level, 1, Integer::sum);
break;
}
}
// Count by hour
if (line.length() > 2) {
String hour = line.substring(0, 2) + ":00";
hourCounts.merge(hour, 1, Integer::sum);
}
// Collect errors
if (line.contains("[ERROR]")) {
errors.add(line);
}
}
}
// Display results
System.out.println("Total log entries: " + totalLines);
System.out.println("\n--- By Level ---");
levelCounts.forEach((level, count) ->
System.out.printf(" %-6s: %3d entries%n", level, count));
System.out.println("\n--- By Hour ---");
hourCounts.forEach((hour, count) -> {
String bar = "█".repeat(count);
System.out.printf(" %s │ %s (%d)%n", hour, bar, count);
});
System.out.println("\n--- Errors ---");
errors.forEach(e -> System.out.println(" ⚠ " + e));
new File("app.log").delete();
}
static void createSampleLog(String filename) throws IOException {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
String[] lines = {
"09:15:23 [INFO] Application started successfully",
"09:15:24 [INFO] Database connection established",
"09:30:01 [DEBUG] Processing request from user123",
"09:30:02 [INFO] Request processed in 45ms",
"10:00:00 [WARN] High memory usage: 85%",
"10:15:33 [INFO] Cache refreshed",
"10:30:45 [ERROR] Failed to connect to payment gateway",
"10:30:46 [INFO] Retrying payment connection...",
"10:30:50 [INFO] Payment connection restored",
"11:00:00 [INFO] Scheduled cleanup started",
"11:00:05 [DEBUG] Removed 234 expired sessions",
"11:30:22 [WARN] Slow query detected: 2.3 seconds",
"12:00:00 [ERROR] OutOfMemoryError in worker thread",
"12:00:01 [INFO] Worker thread restarted",
};
for (String line : lines) {
writer.write(line);
writer.newLine();
}
}
}
}
Output:
| Total log entries | 14 |
| INFO | 8 entries |
| WARN | 2 entries |
| ERROR | 2 entries |
| DEBUG | 2 entries |
| 09 | 00 │ ████ (4) |
| 10 | 00 │ █████ (5) |
| 11 | 00 │ ███ (3) |
| 12 | 00 │ ██ (2) |
| ⚠ 10 | 30:45 [ERROR] Failed to connect to payment gateway |
| ⚠ 12 | 00:00 [ERROR] OutOfMemoryError in worker thread |
Reading from Console with BufferedReader
Example
import java.io.*;
public class ConsoleInput {
public static void main(String[] args) throws IOException {
// BufferedReader with System.in (keyboard input)
BufferedReader reader = new BufferedReader(
new InputStreamReader(System.in));
System.out.println("=== Simple Calculator ===");
System.out.println("Enter expressions like: 5 + 3");
System.out.println("Type 'quit' to exit\n");
String line;
System.out.print("> ");
while ((line = reader.readLine()) != null) {
if (line.equalsIgnoreCase("quit")) break;
try {
String[] parts = line.trim().split("\\s+");
double a = Double.parseDouble(parts[0]);
String op = parts[1];
double b = Double.parseDouble(parts[2]);
double result = switch (op) {
case "+" -> a + b;
case "-" -> a - b;
case "*" -> a * b;
case "/" -> b != 0 ? a / b : Double.NaN;
default -> throw new IllegalArgumentException("Unknown op: " + op);
};
System.out.printf(" = %.2f%n", result);
} catch (Exception e) {
System.out.println(" Invalid input: " + e.getMessage());
}
System.out.print("> ");
}
System.out.println("Goodbye!");
}
}
Common Mistakes
1. Not understanding when to flush
java example
// Data sits in buffer until buffer is full or stream is closed
BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"));
writer.write("Important data!");
// At this point, data might still be in the buffer, NOT on disk!
writer.flush(); // NOW it's on disk
// OR
writer.close(); // Also flushes before closing2. Wrapping already-buffered streams
java example
// ❌ REDUNDANT: BufferedReader already has its own buffer
BufferedReader br = new BufferedReader(
new BufferedReader(new FileReader("file.txt"))); // Double buffering!
// ✅ CORRECT: One layer of buffering
BufferedReader br = new BufferedReader(new FileReader("file.txt"));3. Not checking readLine() for null
java example
// ❌ BAD: NullPointerException when file ends
String line = reader.readLine();
line.trim(); // NPE if line is null!
// ✅ GOOD: Check for null
String line;
while ((line = reader.readLine()) != null) {
line = line.trim();
// process...
}Interview Questions
Q1: What is the default buffer size of BufferedReader?
Answer: 8192 characters (8KB for BufferedReader/BufferedWriter, 8192 bytes for BufferedInputStream/BufferedOutputStream). This can be customized via the constructor.
Q2: What is the difference between flush() and close()?
Answer: flush() writes buffered data to the underlying stream but keeps the stream open. close() calls flush() first, then releases the resource. After close(), you can't write anymore.
Q3: Why is BufferedReader faster than FileReader?
Answer: FileReader makes a system call for each read() invocation. BufferedReader reads a large chunk (8KB) from disk into memory in one system call, then serves subsequent read() requests from this memory buffer. Fewer system calls = much faster.
Q4: Does BufferedWriter's newLine() always write \n?
Answer: No! newLine() writes the platform-specific line separator: \r\n on Windows, \n on Linux/Mac. This ensures files are formatted correctly for the OS. Use it instead of hardcoding \n.
Q5: When should you call flush() explicitly?
Answer: When you need data to be written to the destination immediately without closing the stream. Common cases: (1) log entries that must persist immediately, (2) network communication where the receiver needs data NOW, (3) before reading from the same file in another stream.
Q6: Can BufferedReader read binary files?
Answer: No, BufferedReader is for text (characters). It expects valid character data and will corrupt binary data during encoding/decoding. Use BufferedInputStream for binary files.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Buffered Streams in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, file, handling, buffered
Related Java Master Course Topics
Continue learning this concept
File HandlingByte Streams in JavaComplete guide to Byte Streams in Java — FileInputStream, FileOutputStream, reading and writing binary data, copying files, and understanding byte-level I/O operations.File HandlingCharacter Streams in JavaComplete guide to Character Streams in Java — FileReader, FileWriter, handling Unicode text, character encoding, reading/writing text files with proper internationalization support.File HandlingDeserialization in JavaComplete guide to Deserialization in Java — ObjectInputStream, reading objects from files, type safety, version compatibility, security risks, and best practices for safe deserialization.File HandlingFile Class in JavaComplete guide to the java.io.File class — creating File objects, checking file properties, creating/deleting files and directories, listing contents, and file path operations.File HandlingJava NIO PackageComplete guide to Java NIO (New I/O) — Path, Files, Channels, Buffers, non-blocking I/O, WatchService, and modern file operations that replace traditional java.io approaches.File HandlingSerialization in JavaComplete guide to Serialization in Java — converting objects to byte streams, Serializable interface, ObjectOutputStream, transient keyword, serialVersionUID, and custom serialization.