Rename a file using Java

Check file existence prior to renaming

Before attempting the rename operation, it's good practice to ensure that the destination file name doesn't already exist. This prevents overwriting existing files. Use file.exists() to accomplish this.

// Batman checks for the Joker before throwing a punch
File newFile = new File("newName.txt");
if (!newFile.exists()) {
    boolean renamed = oldFile.renameTo(newFile);
    System.out.println(renamed ? "Renamed successfully" : "Roundhouse Kick Failed");
} else {
    System.out.println("Oops! File already exists!");
}


Errors: Catch 'em all

When renaming files, we must always be prepared to catch the mistakes. Sort of like Pokémon, but less fun. This entails putting your rename block in a try-catch to catch potential IOExceptions.

try {
    File oldFile = new File("oldName.txt");
    File newFile = new File("newName.txt");
    if (!newFile.exists() && oldFile.renameTo(newFile)) {
        System.out.println("Renamed successfully");
    } else {
        System.out.println("The droids you were looking for were not found");
    }
}catch (SecurityException se) {
    System.out.println("Woops! Permission denied. Did you forget to say please?");
}


Graduating from basic renameTo() to Advanced renaming with Files.move()

For situations where a simple renameTo just will not do, you might want to consider using Files.move(). This method gives you more rename controls, including the ability to specify how file replacement should be handled.

import java.nio.file.*;

Path sourcePath      = Paths.get("oldName.txt");
Path destinationPath = Paths.get("newName.txt");

try {
    Files.move(sourcePath, destinationPath, StandardCopyOption.REPLACE_EXISTING);
    System.out.println("Success! The Eagle has landed\"");
} catch (IOException e) {
    System.out.println("Failure! Houston, we have a problem: " + e.getMessage());
}


Expanding your toolkit with third-party utilities

Consider using third-party libraries like Apache Commons IO for more reliable operations, it can simplify your code and provide stronger error handling routines.

// Apache Commons IO: Because two heads are better than one!
import org.apache.commons.io.FileUtils;

File oldFile = new File("oldName.txt");
File newFile = new File("newName.txt");

try {
    FileUtils.moveFile(oldFile, newFile);
    System.out.println("Eureka! Renamed successfully");
} catch (IOException e) {
    System.out.println("I've made a huge mistake: " + e.getMessage());
}


Renaming within the same directory using resolveSibling

When you're working in the same directory, resolveSibling and Files.move() can make renaming snappier.

Path sourcePath = Paths.get("oldName.txt");
Files.move(sourcePath, sourcePath.resolveSibling("newName.txt"));


Wow, that was surprising! 🎉

Ensuring atomicity with FileChannel.transferTo

Sometimes, renaming a file has to be all or nothing—atomic. Use FileChannel.transferTo for just that.

import java.io.*;
import java.nio.channels.FileChannel;

try (FileChannel sourceChannel = new FileInputStream("oldName.txt").getChannel();
     FileChannel destChannel = new FileOutputStream("newName.txt").getChannel()) {

    sourceChannel.transferTo(0, sourceChannel.size(), destChannel);
} catch (IOException e) {
    System.out.println("Whoops, the cake was a lie: " + e.getMessage());
}


Verifying rename success

Guess What! renameTo() returns a boolean value indicating the success or failure of the operation. Always check this return value.

if (oldFile.renameTo(newFile)) {
    System.out.println("Renamed successfully");
} else {
    System.out.println("Houston, we have a problem! Rename Failed");
}
