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 Character Streams in Java — FileReader, FileWriter, handling Unicode text, character encoding, reading/writing text files with proper internationalization support.
What are Character Streams?
Character streams handle I/O of character (text) data. They automatically handle the translation between bytes and characters using a character encoding (like UTF-8, UTF-16).
Example
Byte Streams (for binary): InputStream / OutputStream → 8-bit bytes
Character Streams (for text): Reader / Writer → 16-bit Unicode characters
Why Not Just Use Byte Streams for Text?
Example
import java.io.*;
public class WhyCharacterStreams {
public static void main(String[] args) throws IOException {
String text = "Hello 日本語 العربية 한국어";
// Problem with byte streams: encoding matters!
System.out.println("Original text: " + text);
System.out.println("UTF-8 bytes: " + text.getBytes("UTF-8").length + " bytes");
System.out.println("UTF-16 bytes: " + text.getBytes("UTF-16").length + " bytes");
System.out.println("Characters: " + text.length() + " chars");
// Character streams handle this automatically
try (FileWriter writer = new FileWriter("unicode.txt")) {
writer.write(text);
}
try (FileReader reader = new FileReader("unicode.txt")) {
char[] buffer = new char[100];
int charsRead = reader.read(buffer);
System.out.println("Read back: " + new String(buffer, 0, charsRead));
}
new File("unicode.txt").delete();
}
}
Output:
| Original text | Hello 日本語 العربية 한국어 |
| UTF-8 bytes | 37 bytes |
| UTF-16 bytes | 44 bytes |
| Characters | 20 chars |
| Read back | Hello 日本語 العربية 한국어 |
Character Stream Hierarchy
Example
Reader (abstract) Writer (abstract)
│ │
┌──────────┼──────────┐ ┌────────────┼───────────┐
│ │ │ │ │ │
InputStream FileReader Buffered OutputStreamW FileWriter Buffered
Reader Reader riter Writer
│ │ │
└── Bridge from └── Adds buffering ┌─────────────┘
byte streams + readLine() └── Adds newLine()
+ buffering
FileWriter — Writing Text
java example
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterExample {
public static void main(String[] args) {
System.out.println("=== FileWriter Examples ===\n");
// Method 1: Write strings
try (FileWriter writer = new FileWriter("story.txt")) {
writer.write("Once upon a time in Java land...\n");
writer.write("There lived a programmer who loved clean code.\n");
writer.write("The End.\n");
System.out.println("✓ Written story to file");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 2: Write characters
try (FileWriter writer = new FileWriter("chars.txt")) {
writer.write('H');
writer.write('i');
writer.write('!');
writer.write('\n');
System.out.println("✓ Written individual characters");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 3: Write char array
try (FileWriter writer = new FileWriter("array.txt")) {
char[] greeting = {'H', 'e', 'l', 'l', 'o', '!', '\n'};
writer.write(greeting);
// Write partial array
char[] data = "Java Programming".toCharArray();
writer.write(data, 5, 11); // "Programming"
System.out.println("✓ Written char arrays");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 4: Append mode
try (FileWriter writer = new FileWriter("story.txt", true)) {
writer.write("\n--- Sequel ---\n");
writer.write("The programmer discovered streams...\n");
System.out.println("✓ Appended to story");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Cleanup
new java.io.File("story.txt").delete();
new java.io.File("chars.txt").delete();
new java.io.File("array.txt").delete();
}
}FileReader — Reading Text
Example
import java.io.*;
public class FileReaderExample {
public static void main(String[] args) throws IOException {
// Create test file
try (FileWriter writer = new FileWriter("poem.txt")) {
writer.write("Roses are red,\n");
writer.write("Violets are blue,\n");
writer.write("Java is awesome,\n");
writer.write("And so are you!\n");
}
System.out.println("=== FileReader Examples ===\n");
// Method 1: Read character by character
System.out.println("--- Character by character ---");
try (FileReader reader = new FileReader("poem.txt")) {
int charData;
while ((charData = reader.read()) != -1) {
System.out.print((char) charData);
}
}
// Method 2: Read into char array
System.out.println("\n--- Into char buffer ---");
try (FileReader reader = new FileReader("poem.txt")) {
char[] buffer = new char[20];
int charsRead;
int chunkNum = 1;
while ((charsRead = reader.read(buffer)) != -1) {
String chunk = new String(buffer, 0, charsRead);
System.out.printf("Chunk %d (%d chars): '%s'%n",
chunkNum++, charsRead, chunk.replace("\n", "\\n"));
}
}
// Method 3: Read entire file into String
System.out.println("\n--- Read entire file ---");
try (FileReader reader = new FileReader("poem.txt")) {
StringBuilder content = new StringBuilder();
char[] buffer = new char[1024];
int charsRead;
while ((charsRead = reader.read(buffer)) != -1) {
content.append(buffer, 0, charsRead);
}
System.out.println("File content (" + content.length() + " chars):");
System.out.println(content);
}
new File("poem.txt").delete();
}
}
Output:
| Chunk 1 (20 chars) | 'Roses are red,\nViole' |
| Chunk 2 (20 chars) | 'ts are blue,\nJava is' |
| Chunk 3 (20 chars) | ' awesome,\nAnd so are' |
| Chunk 4 (8 chars) | ' you!\n' |
Character Encoding with InputStreamReader / OutputStreamWriter
FileReader and FileWriter use the system's default encoding. For explicit encoding control, use the bridge classes:
Example
import java.io.*;
import java.nio.charset.StandardCharsets;
public class EncodingExample {
public static void main(String[] args) throws IOException {
String text = "Héllo Wörld! 你好世界 🌍";
System.out.println("=== Character Encoding Demo ===\n");
System.out.println("Text: " + text);
// Write with explicit UTF-8 encoding
try (OutputStreamWriter writer = new OutputStreamWriter(
new FileOutputStream("utf8.txt"), StandardCharsets.UTF_8)) {
writer.write(text);
System.out.println("\n✓ Written as UTF-8");
}
// Write same text as ISO-8859-1 (Latin-1) — will lose non-Latin chars
try (OutputStreamWriter writer = new OutputStreamWriter(
new FileOutputStream("latin1.txt"), "ISO-8859-1")) {
writer.write(text);
System.out.println("✓ Written as ISO-8859-1");
}
// Read back UTF-8
try (InputStreamReader reader = new InputStreamReader(
new FileInputStream("utf8.txt"), StandardCharsets.UTF_8)) {
char[] buffer = new char[100];
int len = reader.read(buffer);
System.out.println("\nRead UTF-8: " + new String(buffer, 0, len));
System.out.println("Encoding used: " + reader.getEncoding());
}
// Read back Latin-1 (lossy)
try (InputStreamReader reader = new InputStreamReader(
new FileInputStream("latin1.txt"), "ISO-8859-1")) {
char[] buffer = new char[100];
int len = reader.read(buffer);
System.out.println("Read Latin-1: " + new String(buffer, 0, len));
System.out.println(" (Chinese characters are corrupted!)");
}
// Show file sizes differ due to encoding
System.out.println("\nFile sizes:");
System.out.println(" UTF-8: " + new File("utf8.txt").length() + " bytes");
System.out.println(" Latin-1: " + new File("latin1.txt").length() + " bytes");
new File("utf8.txt").delete();
new File("latin1.txt").delete();
}
}
Output:
| Text | Héllo Wörld! 你好世界 🌍 |
| Read UTF-8 | Héllo Wörld! 你好世界 🌍 |
| Encoding used | UTF8 |
| Read Latin-1 | H?llo W?rld! ???? ?? |
| UTF-8 | 29 bytes |
| Latin-1 | 19 bytes |
PrintWriter — Convenient Text Output
java example
import java.io.*;
public class PrintWriterExample {
public static void main(String[] args) throws IOException {
System.out.println("=== PrintWriter Demo ===\n");
try (PrintWriter pw = new PrintWriter(new FileWriter("report.txt"))) {
// Like System.out but writes to file!
pw.println("=== Sales Report ===");
pw.println();
pw.printf("%-15s %10s %10s%n", "Product", "Qty", "Revenue");
pw.println("-".repeat(37));
pw.printf("%-15s %10d %10.2f%n", "Laptop", 150, 224999.50);
pw.printf("%-15s %10d %10.2f%n", "Mouse", 500, 7499.00);
pw.printf("%-15s %10d %10.2f%n", "Keyboard", 300, 14997.00);
pw.println("-".repeat(37));
pw.printf("%-15s %10d %10.2f%n", "TOTAL", 950, 247495.50);
pw.println();
pw.print("Generated: ");
pw.println(java.time.LocalDateTime.now());
// Check for errors (PrintWriter doesn't throw exceptions!)
if (pw.checkError()) {
System.out.println("Warning: Write error occurred!");
}
}
// Read and display
try (BufferedReader reader = new BufferedReader(new FileReader("report.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
new File("report.txt").delete();
}
}Output:
Example
=== Sales Report ===
Product Qty Revenue
-------------------------------------
Laptop 150 224999.50
Mouse 500 7499.00
Keyboard 300 14997.00
-------------------------------------
TOTAL 950 247495.50
Generated: 2024-01-15T14:30:45.123
Real-World Example: CSV File Handler
Example
import java.io.*;
import java.util.*;
public class CSVHandler {
// Write data to CSV
static void writeCSV(String filename, String[] headers, List<String[]> rows)
throws IOException {
try (PrintWriter writer = new PrintWriter(new FileWriter(filename))) {
// Write headers
writer.println(String.join(",", headers));
// Write data rows
for (String[] row : rows) {
// Handle values that contain commas
String[] escaped = new String[row.length];
for (int i = 0; i < row.length; i++) {
if (row[i].contains(",") || row[i].contains("\"")) {
escaped[i] = "\"" + row[i].replace("\"", "\"\"") + "\"";
} else {
escaped[i] = row[i];
}
}
writer.println(String.join(",", escaped));
}
}
}
// Read CSV file
static List<String[]> readCSV(String filename) throws IOException {
List<String[]> data = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
String line;
while ((line = reader.readLine()) != null) {
// Simple split (doesn't handle quoted commas)
String[] fields = line.split(",");
data.add(fields);
}
}
return data;
}
public static void main(String[] args) throws IOException {
System.out.println("=== CSV File Handler ===\n");
// Prepare data
String[] headers = {"Name", "Age", "City", "Salary"};
List<String[]> employees = Arrays.asList(
new String[]{"Alice Johnson", "30", "New York", "75000"},
new String[]{"Bob Smith", "25", "San Francisco", "82000"},
new String[]{"Charlie Brown", "35", "Chicago", "68000"},
new String[]{"Diana Prince", "28", "Seattle", "95000"}
);
// Write CSV
writeCSV("employees.csv", headers, employees);
System.out.println("✓ Written employees.csv\n");
// Read and display
List<String[]> data = readCSV("employees.csv");
System.out.printf("%-18s %-5s %-15s %10s%n",
data.get(0)[0], data.get(0)[1], data.get(0)[2], data.get(0)[3]);
System.out.println("-".repeat(55));
for (int i = 1; i < data.size(); i++) {
String[] row = data.get(i);
System.out.printf("%-18s %-5s %-15s %10s%n",
row[0], row[1], row[2], row[3]);
}
new File("employees.csv").delete();
}
}
Output:
Example
=== CSV File Handler ===
✓ Written employees.csv
Name Age City Salary
-------------------------------------------------------
Alice Johnson 30 New York 75000
Bob Smith 25 San Francisco 82000
Charlie Brown 35 Chicago 68000
Diana Prince 28 Seattle 95000
Byte Stream vs Character Stream Comparison
Example
import java.io.*;
public class StreamComparison {
public static void main(String[] args) throws IOException {
String text = "Java ☕ Streams";
System.out.println("=== Byte vs Character Stream ===\n");
System.out.println("Text: \"" + text + "\"");
System.out.println("String length: " + text.length() + " characters");
System.out.println("UTF-8 bytes: " + text.getBytes("UTF-8").length + " bytes");
// Write with byte stream
try (FileOutputStream fos = new FileOutputStream("byte.txt")) {
fos.write(text.getBytes("UTF-8"));
}
// Write with character stream
try (OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("char.txt"), "UTF-8")) {
osw.write(text);
}
System.out.println("\nFile sizes are the same: both use UTF-8 encoding");
System.out.println(" byte.txt: " + new File("byte.txt").length() + " bytes");
System.out.println(" char.txt: " + new File("char.txt").length() + " bytes");
System.out.println("\n--- Key Differences ---");
System.out.println("┌────────────────┬─────────────────────┬──────────────────────┐");
System.out.println("│ Feature │ Byte Streams │ Character Streams │");
System.out.println("├────────────────┼─────────────────────┼──────────────────────┤");
System.out.println("│ Unit │ 8-bit byte │ 16-bit char │");
System.out.println("│ Base classes │ InputStream/Output │ Reader/Writer │");
System.out.println("│ Encoding │ Manual │ Automatic │");
System.out.println("│ Best for │ Binary (img, audio) │ Text files │");
System.out.println("│ Unicode │ No native support │ Full support │");
System.out.println("│ readLine() │ Not available │ BufferedReader │");
System.out.println("└────────────────┴─────────────────────┴──────────────────────┘");
new File("byte.txt").delete();
new File("char.txt").delete();
}
}
Common Mistakes
1. Using FileReader/FileWriter for binary files
java example
// ❌ WRONG: Will corrupt binary data (images, PDFs, etc.)
FileReader reader = new FileReader("image.png");
// ✅ CORRECT: Use byte streams for binary
FileInputStream fis = new FileInputStream("image.png");2. Ignoring character encoding
java example
// ❌ BAD: Uses platform default encoding (unpredictable)
FileWriter writer = new FileWriter("data.txt");
// ✅ GOOD: Specify encoding explicitly
OutputStreamWriter writer = new OutputStreamWriter(
new FileOutputStream("data.txt"), StandardCharsets.UTF_8);
// ✅ BETTER (Java 11+):
Files.writeString(Path.of("data.txt"), content, StandardCharsets.UTF_8);3. Not flushing before close
java example
// ✅ Try-with-resources handles this automatically
try (FileWriter writer = new FileWriter("file.txt")) {
writer.write("data");
} // flush + close called automaticallyInterview Questions
Q1: What is the difference between byte stream and character stream?
Answer: Byte streams (InputStream/OutputStream) work with raw bytes (8-bit) and are suitable for all file types. Character streams (Reader/Writer) work with characters (16-bit Unicode) and handle encoding/decoding automatically, making them ideal for text processing.
Q2: What is InputStreamReader? Why is it called a "bridge"?
Answer: InputStreamReader converts a byte stream (InputStream) into a character stream (Reader). It's called a bridge because it connects the two stream hierarchies, reading bytes from the underlying InputStream and decoding them into characters using a specified charset.
Q3: What encoding does FileReader use by default?
Answer: It uses the platform's default charset (e.g., UTF-8 on Linux, Cp1252 on Windows). Since Java 18, the default is UTF-8 on all platforms. For portability, always specify encoding explicitly using InputStreamReader with a charset.
Q4: Can FileWriter handle Unicode characters like Chinese or emoji?
Answer: Yes, if the file's encoding supports them. FileWriter uses the platform's default encoding. If that's UTF-8, it handles all Unicode. But on some Windows systems with default Latin-1 encoding, non-Latin characters will be corrupted. Always specify UTF-8 explicitly for international text.
Q5: Why should you prefer BufferedReader over FileReader directly?
Answer: FileReader reads from disk one character at a time (one system call per read). BufferedReader wraps FileReader with an internal buffer (default 8KB), dramatically reducing disk I/O. It also provides readLine() method for line-by-line reading.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Character 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, character
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 HandlingBuffered Streams in JavaComplete guide to Buffered Streams in Java — BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter, performance benefits, line-by-line reading, and real-world file processing.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.