MACRO NEPAL
Writing to Text Files in Java
awiskar acharya
October 30, 2025
9:10 am

Java provides multiple ways to write data to text files. Here's a comprehensive guide covering all the major approaches.

1. Core Classes for File Writing

Primary Classes

  • FileWriter - Basic character-oriented file writing
  • BufferedWriter - Efficient buffered writing
  • PrintWriter - Formatted output writing
  • Files (Java NIO) - Modern utility methods

2. Basic File Writing Methods

Method 1: Using FileWriter (Basic)

import java.io.FileWriter;
import java.io.IOException;
public class FileWriterBasic {
public static void main(String[] args) {
// Method 1A: Simple FileWriter (may overwrite existing file)
try (FileWriter writer = new FileWriter("output1.txt")) {
writer.write("Hello, World!\n");
writer.write("This is a text file.\n");
writer.write("Writing using FileWriter.");
System.out.println("File written successfully!");
} catch (IOException e) {
System.out.println("Error writing file: " + e.getMessage());
}
// Method 1B: FileWriter with append mode
try (FileWriter writer = new FileWriter("output1.txt", true)) { // true = append mode
writer.write("\nThis line is appended.\n");
writer.write("Another appended line.");
System.out.println("Content appended successfully!");
} catch (IOException e) {
System.out.println("Error appending to file: " + e.getMessage());
}
}
}

Method 2: Using BufferedWriter (Efficient)

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterExample {
public static void main(String[] args) {
// Using BufferedWriter for better performance
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output2.txt"))) {
writer.write("First line");
writer.newLine(); // Platform-independent new line
writer.write("Second line");
writer.newLine();
writer.write("Third line");
// Writing multiple lines efficiently
String[] lines = {
"This is line 1",
"This is line 2", 
"This is line 3",
"This is line 4"
};
for (String line : lines) {
writer.write(line);
writer.newLine();
}
System.out.println("File written successfully with BufferedWriter!");
} catch (IOException e) {
System.out.println("Error writing file: " + e.getMessage());
}
}
}

Method 3: Using PrintWriter (Formatted Output)

import java.io.PrintWriter;
import java.io.FileWriter;
import java.io.IOException;
public class PrintWriterExample {
public static void main(String[] args) {
// PrintWriter provides formatted output like System.out
try (PrintWriter writer = new PrintWriter(new FileWriter("output3.txt"))) {
// Basic writing
writer.println("This is a line with println");
writer.print("This uses print - ");
writer.println("and then println");
// Formatted output
String name = "John";
int age = 30;
double salary = 45000.50;
writer.printf("Name: %s, Age: %d, Salary: $%.2f%n", name, age, salary);
writer.format("Formatted date: %tF%n", java.time.LocalDate.now());
// Writing different data types
writer.println(true);    // boolean
writer.println(123);     // int
writer.println(45.67);   // double
writer.println('A');     // char
System.out.println("File written successfully with PrintWriter!");
} catch (IOException e) {
System.out.println("Error writing file: " + e.getMessage());
}
// PrintWriter with auto-flush
try (PrintWriter writer = new PrintWriter(new FileWriter("output4.txt"), true)) {
writer.println("Auto-flush enabled");
writer.println("Each println automatically flushes");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}

3. Modern Java NIO Approach (Java 7+)

Using Files.write()

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class FilesWriteExample {
public static void main(String[] args) {
Path path = Paths.get("output_nio.txt");
// Method 1: Write lines from a List (overwrites by default)
try {
List<String> lines = Arrays.asList(
"First line using Files.write()",
"Second line",
"Third line",
"Fourth line"
);
Files.write(path, lines);
System.out.println("File written successfully with Files.write()!");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 2: Append to existing file
try {
List<String> newLines = Arrays.asList(
"This is appended line 1",
"This is appended line 2"
);
Files.write(path, newLines, StandardOpenOption.APPEND);
System.out.println("Content appended successfully!");
} catch (IOException e) {
System.out.println("Error appending: " + e.getMessage());
}
// Method 3: Write a single string
try {
String content = "This is a single string content\nWith multiple lines\n";
Files.writeString(path, content);
System.out.println("String written successfully!");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
// Method 4: Append a single string
try {
String appendContent = "\nThis is appended string content";
Files.writeString(path, appendContent, StandardOpenOption.APPEND);
System.out.println("String appended successfully!");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
}

4. Complete Real-World Examples

Example 1: Writing Configuration Files

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
public class ConfigFileWriter {
public static void writeConfigFile(String filename, Map<String, String> config) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
writer.write("# Application Configuration File");
writer.newLine();
writer.write("# Generated on: " + java.time.LocalDateTime.now());
writer.newLine();
writer.newLine();
for (Map.Entry<String, String> entry : config.entrySet()) {
writer.write(entry.getKey() + "=" + entry.getValue());
writer.newLine();
}
System.out.println("Configuration file '" + filename + "' created successfully!");
} catch (IOException e) {
System.out.println("Error writing config file: " + e.getMessage());
}
}
public static void main(String[] args) {
Map<String, String> config = new HashMap<>();
config.put("database.url", "jdbc:mysql://localhost:3306/mydb");
config.put("database.username", "admin");
config.put("database.password", "secret123");
config.put("server.port", "8080");
config.put("log.level", "INFO");
config.put("cache.enabled", "true");
writeConfigFile("app.config", config);
}
}

Example 2: Writing CSV Files

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
class Employee {
private String name;
private String department;
private double salary;
private int age;
public Employee(String name, String department, double salary, int age) {
this.name = name;
this.department = department;
this.salary = salary;
this.age = age;
}
// Getters
public String getName() { return name; }
public String getDepartment() { return department; }
public double getSalary() { return salary; }
public int getAge() { return age; }
}
public class CSVWriterExample {
public static void writeEmployeesToCSV(String filename, List<Employee> employees) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
// Write header
writer.write("Name,Department,Salary,Age");
writer.newLine();
// Write data rows
for (Employee emp : employees) {
String line = String.format("%s,%s,%.2f,%d",
escapeCSV(emp.getName()),
escapeCSV(emp.getDepartment()),
emp.getSalary(),
emp.getAge());
writer.write(line);
writer.newLine();
}
System.out.println("CSV file '" + filename + "' created with " + 
employees.size() + " records!");
} catch (IOException e) {
System.out.println("Error writing CSV file: " + e.getMessage());
}
}
private static String escapeCSV(String value) {
if (value == null) return "";
// If value contains comma, quote, or newline, wrap in quotes and escape existing quotes
if (value.contains(",") || value.contains("\"") || value.contains("\n")) {
return "\"" + value.replace("\"", "\"\"") + "\"";
}
return value;
}
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("John Doe", "Engineering", 75000.50, 30));
employees.add(new Employee("Jane Smith", "Marketing", 65000.00, 28));
employees.add(new Employee("Bob Johnson", "Sales", 55000.75, 35));
employees.add(new Employee("Alice Brown", "Engineering", 80000.00, 32));
employees.add(new Employee("Charlie Wilson", "HR", 60000.00, 29));
writeEmployeesToCSV("employees.csv", employees);
}
}

Example 3: Log File Writer

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class LogFileWriter {
private String logFile;
private boolean append;
public LogFileWriter(String logFile, boolean append) {
this.logFile = logFile;
this.append = append;
}
public void log(String level, String message) {
String timestamp = LocalDateTime.now().format(
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
String logEntry = String.format("[%s] %s: %s", timestamp, level, message);
try (BufferedWriter writer = new BufferedWriter(
new FileWriter(logFile, append))) {
writer.write(logEntry);
writer.newLine();
} catch (IOException e) {
System.err.println("Error writing to log file: " + e.getMessage());
}
}
public void info(String message) {
log("INFO", message);
}
public void warning(String message) {
log("WARNING", message);
}
public void error(String message) {
log("ERROR", message);
}
public static void main(String[] args) {
LogFileWriter logger = new LogFileWriter("application.log", true);
logger.info("Application started");
logger.info("User 'john_doe' logged in");
logger.warning("Database connection slow");
logger.error("Failed to process request ID: 12345");
logger.info("User 'john_doe' logged out");
System.out.println("Log entries written to application.log");
}
}

5. Advanced File Writing Techniques

Using try-with-resources for Automatic Resource Management

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class AdvancedFileWriting {
public static void writeWithMultipleResources() {
// Multiple resources in try-with-resources
try (FileWriter fw = new FileWriter("advanced_output.txt");
BufferedWriter bw = new BufferedWriter(fw);
PrintWriter pw = new PrintWriter(bw)) {
pw.println("Line 1: Using multiple resources");
pw.printf("Line 2: Formatted number: %d%n", 42);
pw.format("Line 3: Current time: %tT%n", java.time.LocalTime.now());
// Simulate some processing
for (int i = 1; i <= 5; i++) {
pw.printf("Processing item %d...%n", i);
}
System.out.println("File written with multiple resources!");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
public static void writeLargeFile(int numberOfLines) {
String filename = "large_file.txt";
long startTime = System.currentTimeMillis();
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
for (int i = 1; i <= numberOfLines; i++) {
writer.write("This is line number " + i);
writer.newLine();
// Show progress for very large files
if (i % 10000 == 0) {
System.out.printf("Written %d lines...%n", i);
}
}
long endTime = System.currentTimeMillis();
System.out.printf("Finished writing %d lines in %d ms%n", 
numberOfLines, (endTime - startTime));
} catch (IOException e) {
System.out.println("Error writing large file: " + e.getMessage());
}
}
public static void main(String[] args) {
writeWithMultipleResources();
writeLargeFile(100000); // Write 100,000 lines
}
}

Character Encoding Support

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
public class EncodingExample {
public static void writeWithEncoding(String filename, String content, String charset) {
try (BufferedWriter writer = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(filename), charset))) {
writer.write("Charset: " + charset);
writer.newLine();
writer.write(content);
writer.newLine();
writer.write("Special characters: ñ, é, ü, 中文, 🚀");
System.out.println("File written with encoding: " + charset);
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
}
}
public static void main(String[] args) {
String content = "This is a test file with different character encodings.";
writeWithEncoding("utf8.txt", content, StandardCharsets.UTF_8.name());
writeWithEncoding("utf16.txt", content, StandardCharsets.UTF_16.name());
writeWithEncoding("iso8859.txt", content, StandardCharsets.ISO_8859_1.name());
}
}

6. Error Handling and Best Practices

Comprehensive Error Handling

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class RobustFileWriter {
public static boolean writeFileSafely(String filename, String content) {
// Check if file already exists
Path path = Paths.get(filename);
if (Files.exists(path)) {
System.out.println("Warning: File '" + filename + "' already exists. It will be overwritten.");
}
// Check if we have write permissions
if (Files.exists(path) && !Files.isWritable(path)) {
System.out.println("Error: No write permission for file: " + filename);
return false;
}
// Try to write with backup mechanism
String backupFile = filename + ".backup";
try {
// Create backup if file exists
if (Files.exists(path)) {
Files.copy(path, Paths.get(backupFile));
}
// Write the actual file
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
writer.write(content);
System.out.println("File '" + filename + "' written successfully!");
return true;
}
} catch (IOException e) {
System.out.println("Error writing file: " + e.getMessage());
// Restore from backup if write failed
try {
if (Files.exists(Paths.get(backupFile))) {
Files.move(Paths.get(backupFile), path);
System.out.println("Restored original file from backup.");
}
} catch (IOException ex) {
System.out.println("Error restoring backup: " + ex.getMessage());
}
return false;
}
}
public static void main(String[] args) {
String content = "This is important content that should be written safely.\n" +
"With multiple lines of text.\n" +
"And proper error handling.";
boolean success = writeFileSafely("important_data.txt", content);
if (success) {
System.out.println("Operation completed successfully!");
} else {
System.out.println("Operation failed!");
}
}
}

7. Performance Comparison

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
public class PerformanceComparison {
public static void compareWritingMethods(int lineCount) {
List<String> lines = generateLines(lineCount);
System.out.println("Performance comparison for writing " + lineCount + " lines:");
System.out.println("=========================================");
// Method 1: FileWriter
long start = System.currentTimeMillis();
try (FileWriter fw = new FileWriter("test_fw.txt")) {
for (String line : lines) {
fw.write(line + "\n");
}
} catch (IOException e) {
e.printStackTrace();
}
long fwTime = System.currentTimeMillis() - start;
System.out.printf("FileWriter: %d ms%n", fwTime);
// Method 2: BufferedWriter
start = System.currentTimeMillis();
try (BufferedWriter bw = new BufferedWriter(new FileWriter("test_bw.txt"))) {
for (String line : lines) {
bw.write(line);
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
long bwTime = System.currentTimeMillis() - start;
System.out.printf("BufferedWriter: %d ms%n", bwTime);
// Method 3: PrintWriter
start = System.currentTimeMillis();
try (PrintWriter pw = new PrintWriter(new FileWriter("test_pw.txt"))) {
for (String line : lines) {
pw.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
long pwTime = System.currentTimeMillis() - start;
System.out.printf("PrintWriter: %d ms%n", pwTime);
// Method 4: Files.write (NIO)
start = System.currentTimeMillis();
try {
Files.write(Paths.get("test_nio.txt"), lines);
} catch (IOException e) {
e.printStackTrace();
}
long nioTime = System.currentTimeMillis() - start;
System.out.printf("Files.write: %d ms%n", nioTime);
// Cleanup
try {
Files.deleteIfExists(Paths.get("test_fw.txt"));
Files.deleteIfExists(Paths.get("test_bw.txt"));
Files.deleteIfExists(Paths.get("test_pw.txt"));
Files.deleteIfExists(Paths.get("test_nio.txt"));
} catch (IOException e) {
e.printStackTrace();
}
}
private static List<String> generateLines(int count) {
List<String> lines = new ArrayList<>();
for (int i = 0; i < count; i++) {
lines.add("Line number " + i + " with some sample text for testing performance.");
}
return lines;
}
public static void main(String[] args) {
compareWritingMethods(10000); // Compare with 10,000 lines
}
}

Summary

Key Points:

  1. FileWriter: Basic writing, good for simple tasks
  2. BufferedWriter: More efficient for multiple writes, uses buffering
  3. PrintWriter: Best for formatted output, similar to System.out
  4. Files.write(): Modern approach, concise and efficient

Best Practices:

  • Always use try-with-resources for automatic resource management
  • Use BufferedWriter for writing multiple lines efficiently
  • Consider character encoding when dealing with international text
  • Handle exceptions properly and provide meaningful error messages
  • Use Files.write() for simple cases in Java 7+
  • Consider performance for large files (use buffering)

When to Use Which:

  • Simple writes: FileWriter or Files.write()
  • Multiple writes: BufferedWriter
  • Formatted output: PrintWriter
  • Modern code: Files class (Java NIO)
  • Large files: BufferedWriter with appropriate buffer size

Choose the method that best fits your specific use case and Java version requirements.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper