PrologiCode
Progress9 of 16 topics

56% complete

File I/O in Java

File Input/Output (I/O) operations are essential for developing applications that interact with the file system. Java provides comprehensive APIs for reading, writing, and managing files, from the traditional stream-based approach to the more modern NIO (New I/O) and NIO.2 APIs.

What You'll Learn

  • Understanding Java's file I/O architecture
  • Reading and writing text files using different techniques
  • Working with binary files
  • Using buffered streams for improved performance
  • Managing file paths with the Path API
  • File operations with Files class
  • Best practices and common pitfalls

File I/O Architecture in Java

Java provides several layers of abstraction for file operations, organized from low-level to high-level:

Traditional I/O (java.io)

  • Stream-based approach (InputStream, OutputStream)
  • Character-based Readers and Writers
  • Buffered streams for efficiency
  • File and RandomAccessFile classes
  • Available since JDK 1.0

New I/O (java.nio)

  • Channel-based approach
  • Buffer-oriented operations
  • Non-blocking I/O capabilities
  • Memory-mapped file operations
  • Introduced in JDK 1.4, enhanced in Java 7 (NIO.2)

Which API Should You Use?

  • Traditional I/O: Simpler to understand and use for basic file operations.
  • NIO and NIO.2: Better for applications requiring high performance, non-blocking operations, or advanced file system features.
  • Modern Approach: For most new applications, use the Files class (from NIO.2) for simple operations and fall back to traditional I/O for stream-based processing.

Reading Text Files

Java offers multiple ways to read text files, each with its advantages and use cases.

Using BufferedReader

BufferedReader is efficient for reading text files line by line:

java
1import java.io.BufferedReader;
2import java.io.FileReader;
3import java.io.IOException;
4

5public class ReadFileExample {
6    public static void main(String[] args) {
7        // Path to the file
8        String filePath = "example.txt";
9        
10        // Using try-with-resources to automatically close resources
11        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
12            String line;
13            
14            // Read file line by line
15            while ((line = reader.readLine()) != null) {
16                System.out.println(line);
17            }
18            
19        } catch (IOException e) {
20            System.err.println("Error reading file: " + e.getMessage());
21            e.printStackTrace();
22        }
23    }
24}

Using Files Class (Java 7+)

The Files class from NIO.2 provides convenient static methods for common file operations:

java
1import java.nio.file.Files;
2import java.nio.file.Path;
3import java.nio.file.Paths;
4import java.io.IOException;
5import java.util.List;
6

7public class ReadFileModernExample {
8    public static void main(String[] args) {
9        // Path to the file
10        Path path = Paths.get("example.txt");
11        
12        try {
13            // Read all lines at once
14            List<String> lines = Files.readAllLines(path);
15            lines.forEach(System.out::println);
16            
17            // Or read entire file as a String
18            String content = Files.readString(path); // Java 11+
19            System.out.println(content);
20            
21        } catch (IOException e) {
22            System.err.println("Error reading file: " + e.getMessage());
23            e.printStackTrace();
24        }
25    }
26}

Note: Files.readAllLines() loads the entire file into memory, which can be problematic for large files. For large files, use BufferedReader or Files.lines() which returns a Stream.

Writing Text Files

Using BufferedWriter

BufferedWriter provides efficient writing capabilities for text files:

java
1import java.io.BufferedWriter;
2import java.io.FileWriter;
3import java.io.IOException;
4

5public class WriteFileExample {
6    public static void main(String[] args) {
7        String filePath = "output.txt";
8        
9        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
10            writer.write("Hello, Java File I/O!");
11            writer.newLine();
12            writer.write("This is line 2");
13            writer.newLine();
14            writer.write("This is line 3");
15            
16            System.out.println("File written successfully!");
17            
18        } catch (IOException e) {
19            System.err.println("Error writing to file: " + e.getMessage());
20            e.printStackTrace();
21        }
22    }
23}

Using Files Class (Java 7+)

The Files class also provides convenient methods for writing files:

java
1import java.nio.file.Files;
2import java.nio.file.Path;
3import java.nio.file.Paths;
4import java.io.IOException;
5import java.util.List;
6import java.util.Arrays;
7

8public class WriteFileModernExample {
9    public static void main(String[] args) {
10        Path path = Paths.get("output.txt");
11        
12        try {
13            // Write lines to a file
14            List<String> lines = Arrays.asList(
15                "Hello, Java File I/O!",
16                "This is line 2",
17                "This is line 3"
18            );
19            
20            Files.write(path, lines);
21            System.out.println("File written successfully!");
22            
23            // Append to existing file
24            Files.write(path, Arrays.asList("This is line 4"), 
25                        java.nio.file.StandardOpenOption.APPEND);
26            
27        } catch (IOException e) {
28            System.err.println("Error writing to file: " + e.getMessage());
29            e.printStackTrace();
30        }
31    }
32}

Working with Binary Files

For reading and writing binary data, Java provides several mechanisms:

Using InputStream and OutputStream

java
1import java.io.FileInputStream;
2import java.io.FileOutputStream;
3import java.io.IOException;
4

5public class BinaryFileExample {
6    public static void main(String[] args) {
7        String inputFile = "source.jpg";
8        String outputFile = "destination.jpg";
9        
10        try (FileInputStream in = new FileInputStream(inputFile);
11             FileOutputStream out = new FileOutputStream(outputFile)) {
12            
13            byte[] buffer = new byte[1024];
14            int bytesRead;
15            
16            // Read from input and write to output
17            while ((bytesRead = in.read(buffer)) != -1) {
18                out.write(buffer, 0, bytesRead);
19            }
20            
21            System.out.println("File copied successfully!");
22            
23        } catch (IOException e) {
24            System.err.println("Error copying file: " + e.getMessage());
25            e.printStackTrace();
26        }
27    }
28}

Using Files Class for Binary Data

java
1import java.nio.file.Files;
2import java.nio.file.Path;
3import java.nio.file.Paths;
4import java.io.IOException;
5

6public class BinaryFileModernExample {
7    public static void main(String[] args) {
8        Path sourcePath = Paths.get("source.jpg");
9        Path destinationPath = Paths.get("destination.jpg");
10        
11        try {
12            // Copy file
13            Files.copy(sourcePath, destinationPath);
14            System.out.println("File copied successfully!");
15            
16            // Read all bytes
17            byte[] imageData = Files.readAllBytes(sourcePath);
18            System.out.println("Image size: " + imageData.length + " bytes");
19            
20            // Write bytes to a new file
21            Files.write(Paths.get("another-copy.jpg"), imageData);
22            
23        } catch (IOException e) {
24            System.err.println("Error handling binary file: " + e.getMessage());
25            e.printStackTrace();
26        }
27    }
28}

Working with File Paths

The Path interface (introduced in Java 7) provides a powerful way to work with file paths:

java
1import java.nio.file.Path;
2import java.nio.file.Paths;
3import java.io.File;
4

5public class PathExample {
6    public static void main(String[] args) {
7        // Creating paths
8        Path absolutePath = Paths.get("/home/user/documents/file.txt");
9        Path relativePath = Paths.get("documents", "file.txt");
10        
11        // Converting between File and Path
12        File file = new File("/home/user/documents/file.txt");
13        Path pathFromFile = file.toPath();
14        File fileFromPath = absolutePath.toFile();
15        
16        // Getting information from a path
17        System.out.println("File name: " + absolutePath.getFileName());
18        System.out.println("Parent directory: " + absolutePath.getParent());
19        System.out.println("Root: " + absolutePath.getRoot());
20        System.out.println("Is absolute: " + absolutePath.isAbsolute());
21        
22        // Normalizing paths
23        Path redundantPath = Paths.get("/home/user/../user/documents/./file.txt");
24        Path normalizedPath = redundantPath.normalize();
25        System.out.println("Normalized path: " + normalizedPath);
26        
27        // Resolving paths
28        Path basePath = Paths.get("/home/user");
29        Path resolvedPath = basePath.resolve("documents/file.txt");
30        System.out.println("Resolved path: " + resolvedPath);
31        
32        // Relative paths
33        Path path1 = Paths.get("/home/user/documents");
34        Path path2 = Paths.get("/home/user/pictures");
35        Path relativized = path1.relativize(path2);
36        System.out.println("Relativized path: " + relativized); // Output: ../pictures
37    }
38}

File Operations with Files Class

The Files class provides numerous static methods for file operations:

java
1import java.nio.file.Files;
2import java.nio.file.Path;
3import java.nio.file.Paths;
4import java.nio.file.StandardCopyOption;
5import java.nio.file.attribute.BasicFileAttributes;
6import java.io.IOException;
7

8public class FilesOperationsExample {
9    public static void main(String[] args) {
10        try {
11            Path filePath = Paths.get("example.txt");
12            Path dirPath = Paths.get("example-dir");
13            
14            // Check if file exists
15            boolean exists = Files.exists(filePath);
16            System.out.println("File exists: " + exists);
17            
18            // Create a new file
19            if (!exists) {
20                Files.createFile(filePath);
21                System.out.println("File created");
22            }
23            
24            // Create directory
25            Files.createDirectories(dirPath);
26            
27            // Copy file with replace option
28            Path targetPath = Paths.get("example-copy.txt");
29            Files.copy(filePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
30            
31            // Move/rename file
32            Path newPath = Paths.get("example-renamed.txt");
33            Files.move(targetPath, newPath, StandardCopyOption.REPLACE_EXISTING);
34            
35            // Delete file
36            Files.delete(newPath);
37            // Or use deleteIfExists to avoid exceptions
38            boolean deleted = Files.deleteIfExists(Paths.get("non-existent.txt"));
39            
40            // Get file attributes
41            BasicFileAttributes attr = Files.readAttributes(filePath, BasicFileAttributes.class);
42            System.out.println("Creation time: " + attr.creationTime());
43            System.out.println("Last modified: " + attr.lastModifiedTime());
44            System.out.println("Size: " + attr.size() + " bytes");
45            System.out.println("Is directory: " + attr.isDirectory());
46            System.out.println("Is regular file: " + attr.isRegularFile());
47            
48            // List directory contents
49            Files.list(dirPath).forEach(System.out::println);
50            
51        } catch (IOException e) {
52            System.err.println("Error: " + e.getMessage());
53            e.printStackTrace();
54        }
55    }
56}

Best Practices for File I/O

Use try-with-resources

Always use try-with-resources for automatically closing file resources, preventing resource leaks.

try (BufferedReader reader = new BufferedReader(new FileReader(file))) { // Use reader here }

Use Buffered Streams

Always wrap I/O streams with buffered streams (BufferedReader, BufferedWriter, etc.) for improved performance.

BufferedReader reader = new BufferedReader(new FileReader(file));

Handle Character Encoding

Always specify character encoding when reading/writing text files to avoid platform-dependent issues.

Files.write(path, lines, StandardCharsets.UTF_8);

Use NIO for Modern Code

Prefer using the Files class and Path interface for most file operations in new code for better readability and error handling.

Real-World Example: Log File Analyzer

Here's a practical example that processes a log file to extract and analyze information:

java
1import java.nio.file.Files;
2import java.nio.file.Path;
3import java.nio.file.Paths;
4import java.io.IOException;
5import java.util.Map;
6import java.util.HashMap;
7import java.util.List;
8import java.util.stream.Collectors;
9import java.time.LocalDateTime;
10import java.time.format.DateTimeFormatter;
11

12public class LogAnalyzer {
13    public static void main(String[] args) {
14        Path logFile = Paths.get("server.log");
15        
16        try {
17            // Read all lines from the log file
18            List<String> logLines = Files.readAllLines(logFile);
19            
20            // Extract statistics
21            Map<String, Integer> ipCounts = new HashMap<>();
22            Map<String, Integer> urlCounts = new HashMap<>();
23            int errorCount = 0;
24            
25            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
26            LocalDateTime startTime = LocalDateTime.parse("2023-01-01 00:00:00", formatter);
27            
28            // Process each log line
29            for (String line : logLines) {
30                if (line.contains("ERROR")) {
31                    errorCount++;
32                }
33                
34                // Extract IP address (assuming format: [IP] - Other log info)
35                int ipStart = line.indexOf('[');
36                int ipEnd = line.indexOf(']');
37                if (ipStart >= 0 && ipEnd > ipStart) {
38                    String ip = line.substring(ipStart + 1, ipEnd);
39                    ipCounts.put(ip, ipCounts.getOrDefault(ip, 0) + 1);
40                }
41                
42                // Extract URL (assuming format: "GET /url HTTP/1.1")
43                int urlStart = line.indexOf("GET ");
44                if (urlStart >= 0) {
45                    int urlEnd = line.indexOf(" HTTP", urlStart);
46                    if (urlEnd > urlStart) {
47                        String url = line.substring(urlStart + 4, urlEnd);
48                        urlCounts.put(url, urlCounts.getOrDefault(url, 0) + 1);
49                    }
50                }
51            }
52            
53            // Find most frequent IP address
54            String mostFrequentIP = ipCounts.entrySet().stream()
55                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
56                .map(Map.Entry::getKey)
57                .findFirst()
58                .orElse("None");
59                
60            // Find most accessed URL
61            String mostAccessedURL = urlCounts.entrySet().stream()
62                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
63                .map(Map.Entry::getKey)
64                .findFirst()
65                .orElse("None");
66            
67            // Generate and write report
68            List<String> reportLines = List.of(
69                "Log Analysis Report",
70                "-----------------",
71                "Total log entries: " + logLines.size(),
72                "Error count: " + errorCount,
73                "Most frequent IP: " + mostFrequentIP + " (" + ipCounts.getOrDefault(mostFrequentIP, 0) + " hits)",
74                "Most accessed URL: " + mostAccessedURL + " (" + urlCounts.getOrDefault(mostAccessedURL, 0) + " hits)",
75                "",
76                "Top 5 IPs:",
77                ipCounts.entrySet().stream()
78                    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
79                    .limit(5)
80                    .map(e -> e.getKey() + ": " + e.getValue() + " hits")
81                    .collect(Collectors.joining("\n"))
82            );
83            
84            // Write report to file
85            Files.write(Paths.get("log-report.txt"), reportLines);
86            System.out.println("Log analysis complete. Report written to log-report.txt");
87            
88        } catch (IOException e) {
89            System.err.println("Error analyzing logs: " + e.getMessage());
90            e.printStackTrace();
91        }
92    }
93}

Summary

Java provides a rich set of APIs for file I/O operations:

  • Traditional I/O (java.io) offers stream-based file operations
  • NIO and NIO.2 (java.nio) provide more advanced channel and buffer-based operations
  • The Files class and Path interface simplify common file operations
  • Proper resource management with try-with-resources is essential
  • Use buffered operations for better performance
  • Handle character encoding explicitly for text files

Mastering file I/O is crucial for many Java applications, from simple data persistence to complex data processing systems. With the knowledge from this tutorial, you can efficiently read, write, and manipulate files in your Java applications.

Previous: Exception HandlingNext: Java Collections

Related Tutorials

Exception Handling in Java

Learn about try-catch blocks and handling exceptions in Java.

Learn more

Java Collections

Understand Java collections framework for managing groups of objects.

Learn more

Java Streams API

Process collections of objects in a functional style.

Learn more