How to use the new API enhancements in java.nio.file in Java 17

By Wayan in IO, Java 17 0 Comment

Java 17 introduced several significant enhancements in the java.nio.file package, focusing on improving file system operations, security, and performance. Below is an explanation of the new APIs and available enhancements, with examples demonstrating how to use them.

Key API Enhancements in java.nio.file for Java 17

1. Files.mismatch()

The method Files.mismatch(Path, Path) was added to efficiently compare two files. It helps identify the position where two files differ or returns -1 if the files are identical.

Example:

package org.kodejava.nio;

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

public class FilesMismatchExample {
    public static void main(String[] args) throws IOException {
        Path file1 = Path.of("file1.txt");
        Path file2 = Path.of("file2.txt");

        // Create sample files
        Files.writeString(file1, "Hello, world!");
        Files.writeString(file2, "Hello, Java!");

        long mismatchPosition = Files.mismatch(file1, file2);

        if (mismatchPosition == -1) {
            System.out.println("Files are identical.");
        } else {
            System.out.println("Files differ beginning at byte position: " + mismatchPosition);
        }
    }
}

Usage Notes:

  • This method is especially useful for large files where reading and comparing the entire contents manually would be inefficient.
  • For identical files, the method returns -1.

2. Files.copy() Enhancements

The Files.copy(InputStream in, Path target, CopyOption... options) method now supports the StandardCopyOption.REPLACE_EXISTING option to overwrite existing files directly.

Example:

package org.kodejava.nio;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class FilesCopyExample {
    public static void main(String[] args) throws Exception {
        Path targetPath = Path.of("output.txt");

        try (InputStream inputStream = new ByteArrayInputStream("File content".getBytes())) {
            Files.copy(inputStream, targetPath, StandardCopyOption.REPLACE_EXISTING);
        }
        System.out.println("File copied successfully to: " + targetPath);
    }
}

Usage Notes:

  • Prior to Java 17, replacing existing files required explicitly deleting the file first.
  • This enhancement simplifies file replacement logic.

3. Support for Hidden Files in Files.isHidden()

Java 17 improves the handling of hidden files for certain platforms where determining this attribute was inconsistent (e.g., macOS and Linux).

Example:

package org.kodejava.nio;

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

public class HiddenFileExample {
    public static void main(String[] args) throws Exception {
        Path filePath = Path.of(".hiddenFile");
        Files.createFile(filePath);

        if (Files.isHidden(filePath)) {
            System.out.println(filePath + " is a hidden file.");
        } else {
            System.out.println(filePath + " is not a hidden file.");
        }
    }
}

4. File Permission Enhancements on Unix-like Systems

Java 17 improves security and performance for managing file permissions using PosixFilePermissions.

Example:

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;

public class FilePermissionExample {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("example.txt");
        Files.createFile(path);

        Set<PosixFilePermission> permissions = PosixFilePermissions.fromString("rw-r--r--");
        Files.setPosixFilePermissions(path, permissions);

        System.out.println("File permissions: " + Files.getPosixFilePermissions(path));
    }
}

Usage Note:

  • This improvement provides more robust support for file permissions on Unix-like operating systems.

Summary Table of Changes

Enhancement Description Java Version
Files.mismatch() Compares two files to find the first mismatch position or confirms equality Java 17
Enhanced Files.copy() Overwrite files without manually deleting them Java 17
Improved Files.isHidden() Better cross-platform handling of hidden files Java 17
File Permission Enhancements Improved security and performance on Unix-like systems Java 17

These enhancements improve efficiency, accessibility, and usability when working with file system operations. You can start using them to simplify your file-handling logic in Java applications.

How to recursively rename files with a specific suffix in Java?

By Wayan in IO 0 Comment

The following code snippet show you how to recursively rename files with a specific suffix. In this example we are renaming a collection of resource bundles files which ends with _in.properties into _id.properties. The code snippet also count the number of files affected by the process. We use the Files.move() method to rename the file, if you want to copy the files instead of renaming them, then you can use the Files.copy() method.

Here is the complete code snippet:

package org.kodejava.io;

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

public class RenameResourceBundles {
    public static void main(String[] args) {
        String startDirectory = "C:/Projects/Hello";
        AtomicInteger counter = new AtomicInteger(0);

        try (Stream<Path> paths = Files.walk(Paths.get(startDirectory))) {
            paths.filter(Files::isRegularFile)
                    .filter(path -> path.toString().endsWith("_in.properties"))
                    .forEach(path -> renameFile(path, counter));
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Total files renamed: " + counter.get());
    }

    private static void renameFile(Path path, AtomicInteger counter) {
        try {
            String newName = path.toString().replace("_in.properties", "_id.properties");
            Path newPath = Paths.get(newName);
            Files.move(path, newPath);
            System.out.println("Renamed: " + path + " to " + newPath);
            counter.incrementAndGet();
        } catch (IOException e) {
            System.out.println("Failed to rename: " + path);
            e.printStackTrace();
        }
    }
}

This code will recursively search through all subdirectories starting from the specified root directory and rename any files that end with _in.properties to _id.properties. The process prints the renamed file, and finally outputs the total number of files that were successfully renamed after traversing the directory tree.

The explanation of the code snippet above:

  • The Files.walk method is used to traverse the directory tree starting from the given directory.
  • The filter method is used to select only regular files that end with _in.properties.
  • The renameFile method handles the renaming of each file, replacing _in.properties with _id.properties.
  • An AtomicInteger named counter keeps track of the number of files renamed. AtomicInteger is used to handle the count in a thread-safe manner, which is useful if the code is ever modified to use parallel streams or multi-threading.
  • Inside the renameFile method, counter.incrementAndGet() is called each time a file is successfully renamed. This increments the counter by one.
  • After the Files.walk operation, the total number of renamed files is printed using System.out.println("Total files renamed: " + counter.get());.

How do I use Files.walk() method to read directory contents?

By Wayan in IO, Java 8 0 Comment

The Files.walk() method in Java is a handy method when it comes to reading directory contents. Files.walk() method returns a Stream object that you can use to process each of the elements (files or directories) in the directory structure.

This method walks the file tree in a depth-first manner, starting from the given path that you provide as its parameter. It visits all files and directories in the file tree.

Here’s a simple example of how to use it. In this case, we are printing out the path to each file/directory.

package org.kodejava.io;

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 FileWalkExample {
    public static void main(String[] args) {
        Path start = Paths.get("D:/Games");
        try (Stream<Path> stream = Files.walk(start)) {
            stream.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Files.walk() also supports a maximum depth argument, so you can limit how deep into the directory structure you want to go. For example, Files.walk(start, 2) would only go two levels deep.

Please note: You should always close the stream after you’re done with it to free up system resources. This is done automatically here with a try-with-resources statement.

How do I list files in a given directory using Files.list() method?

By Wayan in Core API, IO, Java 8 0 Comment

In Java, you can use the Files.list() method to list all files in a given directory. Files.list(Path dir) is a method in the java.nio.file.Files class.

This method returns a Stream that is lazily populated with Path by walking the directory tree rooted at a given starting file. The file tree is traversed depth-first, the elements in the stream are Path objects that are obtained as if by resolving the name of the directory entry against dir.

The stream is “lazy” because not all the Paths are populated at once. This can be beneficial if you have a large number of files in your directory.

Here’s a code snippet that shows you how to do it:

package org.kodejava.io;

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 ListFiles {
    public static void main(String[] args) {
        // Replace with your directory
        Path path = Paths.get("D:/Games");

        // Use try-with-resources to get auto-closeable stream
        try (Stream<Path> paths = Files.list(path)) {
            paths
                    .filter(Files::isRegularFile)  // filter out subdirectories
                    .forEach(System.out::println); // print file names
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This code lists all files in the specified directory ("D:/Games" in this case). It uses a stream of Path obtained from Files.list(), filters out the paths that are not regular files using Files.isRegularFile(), and finally prints each file name using System.out.println().

Remember to replace "D:/Games" with the actual directory you want to list files from. Also, the Files.list() method throws an IOException, so you must handle this exception in a try-catch block or declare it in the method signature.

How do I use BufferedReader.lines() method to read file?

By Wayan in Core API, IO, Java 8 0 Comment

The BufferedReader.lines() method is a Java 8 method that returns a Stream, each element of which is a line read from the BufferedReader. This allows you to perform operations on each line with Java’s functional programming methods.

Returning a Stream of strings makes the BufferedReader.lines() method very efficient in terms of memory usage when working with large files. It reads the file line by line, instead of loading the entire file into memory at once.

Here is how it’s used to read from a file:

package org.kodejava.io;

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 BufferedReaderLines {
    public static void main(String[] args) {
        Path path = Paths.get("README.MD");
        try (BufferedReader reader = Files.newBufferedReader(path)) {
            reader.lines().forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This code opens a BufferedReader on the file located at the given path and uses the lines() method to get a Stream of lines from the file. Each line is then printed to the console using the System.out::println method reference.

The try-with-resources statement is there to ensure that the BufferedReader is closed after we’re done with it, even if an exception was thrown. The catch block is to handle a potential IOException which would be due to a file read error.

Bear in mind that not every situation requires or benefits from using streams, and in some cases, traditional processing methods might be more suitable. But when dealing with large datasets and when you wish to write declarative, clean, and efficient code, this method can be extremely useful.