How do I zip and unzip files with Java I/O?

By I Wayan Saryada in IO 0 Comment

In Java, handling ZIP files is primarily done using the java.util.zip package. The key classes you’ll use are ZipOutputStream for creating (zipping) files and ZipInputStream (or ZipFile) for extracting (unzipping) them.

Here is a breakdown of how to perform both operations.

1. Zipping Files

To zip files, you wrap a FileOutputStream with a ZipOutputStream. For every file you want to add, you create a ZipEntry and write the file’s data to the stream.

package org.kodejava.io;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class ZipExample {
    public static void main(String[] args) {
        String sourceFile = "example.txt";
        String zipFile = "compressed.zip";

        try (FileOutputStream fos = new FileOutputStream(zipFile);
             ZipOutputStream zos = new ZipOutputStream(fos);
             FileInputStream fis = new FileInputStream(sourceFile)) {

            // Create a new ZipEntry for the file
            ZipEntry zipEntry = new ZipEntry(sourceFile);
            zos.putNextEntry(zipEntry);

            // Read source file and write to the ZipOutputStream
            byte[] buffer = new byte[1024];
            int length;
            while ((length = fis.read(buffer)) >= 0) {
                zos.write(buffer, 0, length);
            }

            zos.closeEntry();
            System.out.println("File zipped successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. Unzipping Files

To extract files, you use ZipInputStream to iterate through each ZipEntry. For each entry, you create a FileOutputStream to write the data back to the disk.

package org.kodejava.io;

import java.io.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class UnzipExample {
    public static void main(String[] args) {
        String zipFile = "compressed.zip";
        String destDir = "output_folder";

        File dir = new File(destDir);
        if (!dir.exists()) dir.mkdirs();

        try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFile))) {
            ZipEntry entry = zis.getNextEntry();

            while (entry != null) {
                File filePath = new File(destDir, entry.getName());

                // Ensure parent directories exist (crucial for nested zips)
                if (entry.isDirectory()) {
                    filePath.mkdirs();
                } else {
                    new File(filePath.getParent()).mkdirs();
                    try (FileOutputStream fos = new FileOutputStream(filePath)) {
                        byte[] buffer = new byte[1024];
                        int len;
                        while ((len = zis.read(buffer)) > 0) {
                            fos.write(buffer, 0, len);
                        }
                    }
                }
                zis.closeEntry();
                entry = zis.getNextEntry();
            }
            System.out.println("Unzipped successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Pro-Tips:

  • Try-with-resources: Always use try-with-resources (as shown above) to ensure that streams are closed automatically, preventing memory leaks and file locks.
  • Buffering: For large files, wrapping your streams in BufferedInputStream and BufferedOutputStream can significantly improve performance.
  • ZipFile vs ZipInputStream: If you need random access to specific files within a ZIP without reading the whole thing, use the ZipFile class instead of ZipInputStream.
  • ZipSlip Vulnerability: When unzipping, always validate that the entry’s name doesn’t contain .. (parent directory references) to prevent files from being written outside the target directory.

How do I use Files.walk() to traverse directories?

By I Wayan Saryada in IO 0 Comment

To use Files.walk to traverse directories, you call the method with a starting Path. It returns a Stream<Path> that lazily populates as you traverse the file tree in a depth-first manner.

The most important best practice when using Files.walk is to use it within a try-with-resources block. This ensures that the underlying resources (the directory stream) are closed properly after the operation completes.

Basic Usage Example

Here is how you can list every file and directory starting from a specific path:

package org.kodejava.nio;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class WalkExample {
    public static void main(String[] args) {
        Path startPath = Paths.get(".");

        try (Stream<Path> stream = Files.walk(startPath)) {
            stream.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Filtering and Customizing the Traversal

  1. Limiting Depth: You can provide a maxDepth argument to control how many levels deep the traversal should go. 
    // Only traverse up to 2 levels deep
try (Stream<Path> stream = Files.walk(startPath, 2)) {
    stream.forEach(System.out::println);
}
  2. Filtering for Files only: Use the filter method on the Stream to exclude directories. 
    try (Stream<Path> stream = Files.walk(startPath)) {
    stream.filter(Files::isRegularFile)
          .forEach(System.out::println);
}
  3. Handling Symbolic Links: By default, Files.walk does not follow symbolic links. You can enable this by passing FileVisitOption.FOLLOW_LINKS. 
    import java.nio.file.FileVisitOption;

// ...
try (Stream<Path> stream = Files.walk(startPath, FileVisitOption.FOLLOW_LINKS)) {
    stream.forEach(System.out::println);
}

Key Considerations

  • IOException: Unlike many Stream operations, Files.walk can throw an IOException during initialization. Also, if an error occurs during iteration (e.g., a permission issue), it will throw an UncheckedIOException.
  • Memory Efficiency: Because it returns a Stream, it is memory-efficient for large directory structures as it doesn’t load all paths into memory at once.
  • Alternatives: If you need more control (like specific logic when entering a directory or handling errors for specific files), consider using Files.walkFileTree with a FileVisitor.

How do I create a temporary file with Files.createTempFile()?

By I Wayan Saryada in IO 0 Comment

To create a temporary file using java.nio.file.Files.createTempFile, you can use one of two main overloaded methods. This is part of the Java NIO.2 API and is generally preferred over the older File.createTempFile because it returns a Path object and allows for better error handling and file attributes.

1. In the Default Temporary Directory

If you only care about the prefix and suffix, Java will place the file in the system’s default temporary folder.

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public class TempFileExample {
    public static void main(String[] args) {
        try {
            // Prefix: "log_", Suffix: ".tmp"
            // Result: /tmp/log_123456789.tmp (the path varies by OS)
            Path tempFile = Files.createTempFile("log_", ".tmp");

            System.out.println("Temporary file created at: " + tempFile);

            // Optionally, delete the file on exit (NIO doesn't have a direct 
            // method like File, so we usually use a shutdown hook or delete
            // manually)
            tempFile.toFile().deleteOnExit();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. In a Specific Directory

If you want the temporary file to be created in a specific folder, pass a Path as the first argument.

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CustomTempFileExample {
    public static void main(String[] args) {
        Path customDir = Paths.get("C:/my_app/temp");

        try {
            // Ensure the directory exists first
            if (Files.notExists(customDir)) {
                Files.createDirectories(customDir);
            }

            Path tempFile = Files.createTempFile(customDir, "data_", ".dat");
            System.out.println("File created in custom dir: " + tempFile);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Key Differences to Note:

  • Prefix/Suffix: The prefix must be at least three characters long. The suffix can be null, in which case .tmp is used.
  • Security: Files.createTempFile creates the file with restricted permissions (readable/writable only by the owner) by default on many systems, which is more secure than the older File.createTempFile.
  • Return Type: It returns a java.nio.file.Path object, which is the modern way to handle file paths in Java.

How do I use Files.lines() to process a text file line by line?

By I Wayan Saryada in IO 0 Comment

To use Files.lines() to process a text file line by line in Java, you should follow the pattern of returning a Stream<String> within a try-with-resources block. This approach is memory-efficient because it reads the file lazily, meaning it doesn’t load the entire file into memory at once.

Basic Implementation

package org.kodejava.nio;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileStreamExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        // Use try-with-resources to ensure the stream (and underlying file) is closed
        try (Stream<String> lines = Files.lines(path)) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
    }
}

Advanced Processing (Filtering and Mapping)

The power of Files.lines() comes from the Stream API, allowing you to filter, transform, or search through the file content easily:

try (Stream<String> lines = Files.lines(path)) {
    long count = lines
        .filter(line -> line.contains("ERROR")) // Only keep lines with "ERROR"
        .map(String::trim)                       // Remove whitespace
        .peek(System.out::println)               // Print each matching line
        .count();                                // Count the occurrences

    System.out.println("Total errors found: " + count);
} catch (IOException e) {
    e.printStackTrace();
}

Key Considerations:

  1. Try-with-Resources is Mandatory: Unlike most streams, the stream returned by Files.lines() holds an open resource (the file handle). If you don’t close it, you may run into a “too many open files” error.
  2. Character Encoding: By default, Files.lines() uses UTF-8. If your file uses a different encoding (like ISO-8859-1), you can specify it as a second argument: 
    Files.lines(path, StandardCharsets.ISO_8859_1)

  3. Performance: For very large files, Files.lines() is significantly more efficient than Files.readAllLines(), which would attempt to store every line in a List<String>, potentially causing an OutOfMemoryError.

How do I use Files.newBufferedReader() with try-with-resources?

By I Wayan Saryada in IO 0 Comment

Using Files.newBufferedReader with a try-with-resources block is the best practice for reading files in Java. Since BufferedReader implements AutoCloseable, the try-with-resources statement ensures that the file handle is automatically closed when the block is finished, even if an exception occurs.

Here is how you can implement it:

Basic Usage

This is the simplest way to read a file line-by-line using the default UTF-8 charset.

package org.kodejava.nio;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class ReadFileExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");

        // The resource is declared inside the try parentheses
        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            // Handle potential issues like a file not found or access errors
            e.printStackTrace();
        }
    }
}

Key Highlights

  • Automatic Cleanup: You don’t need a finally block to call reader.close().
  • Charset Support: If your file uses a specific encoding (like ISO-8859-1), you can pass it as a second argument: 
    try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.ISO_8859_1)) { ... }
  • Modern Alternative: Since you are using Java 25, if you want to read all lines into a stream for processing, you can use the lines() method inside the block: 
    try (BufferedReader reader = Files.newBufferedReader(path)) {
    reader.lines().forEach(System.out::println);
}

Why use Files.newBufferedReader over new BufferedReader(new FileReader(...))?

  1. Path API: It works seamlessly with java.nio.file.Path, which is more robust than the old File class.
  2. Explicit Charset: It defaults to UTF-8 (unlike older methods which might use the system’s default encoding), making your code more portable.
  3. Better Error Handling: It provides more descriptive IOException subclasses (like NoSuchFileException).