Writing to Text Files in Java

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:

FileWriter: Basic writing, good for simple tasks
BufferedWriter: More efficient for multiple writes, uses buffering
PrintWriter: Best for formatted output, similar to System.out
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.