如果在目标目录中有一个同名的文件（java），我如何制作一个被重命名的移动文件？

Question

我正在为我的电脑编写一个移动文件程序，要完成它我需要重命名一个移动文件，如果在目标目录中已经有一个同名的文件，我该怎么做？

Answer 1

One could use File.move and use CopyOption s. But it seems more elegant to check the existence of the target.

void move(Path source, Path target) throws IOException {
    int fileno = 0;
    while (Files.exist(target)) {
        target = ...
        ++fileno;
    }
    // Files.createDirectories(target.getParent());
    Files.move(source, target);
}

In java the convention is that the target is not a directory (the new parent).

Answer 2

It's a programming language; you would program the behaviour you want. There is nothing 'baked in', if that's what you were thinking.

As with most things that could potentially interact with other threads or applications running simultaneously, you don't check-and-act - because other apps or threads could change the situation in between your 'check' and your 'act' - instead, you act-then-check: You just do the thing, and catch exceptions that indicate the thing cannot be done due to failing checks, and act accordingly. In other words, don't do something like:

while (file.exists()) file = incrementSomething();
writeTo(file);

That's check-then-act. Don't do that.

Instead you'd first just move it, and then catch the exception that indicates that it cannot be moved because the 'target' already exists and you did not specify that overwriting is acceptable.

It's your program, you decide what you want to do when this happens. Perhaps you want to append (1) to the file name and try again, then (2) , and so on, all the way to (999) and once you get that far, just stop and crash. Or perhaps you want to roll up a random sequence of 6 characters and append that, which is a heck of a lot faster if this 'naming conflict' scenario is likely. That's the joy of programming: Anything's possible, you decide what you want and then you write it just like that.

Let's say you want the (1) thing. It would look something like:

public void move(Path sourceFile, Path targetDir) throws IOException {
  try {
    Files.move(sourceFile, targetDir.resolve(sourceFile.getFileName()));
  } catch (FileAlreadyExistsException e) {
    String baseName = sourceFile.getFileName().toString();
    int lastDot = baseName.lastIndexOf('.');
    String prefix = lastDot == -1 ? baseName : baseName.substring(0, lastDot);
    String suffix = lastDot == -1 ? "" : baseName.substring(lastDot);
    moveIncremental(sourceFile, targetDir, prefix, suffix, 1);
  }
}

private void moveIncremental(Path sourceFile, Path targetDir, String prefix, String suffix, int counter) throws IOException {

  Path target = targetDir.resolve(prefix + " (" + counter + ")" + suffix);
  try {
    Files.move(sourceFile, target);
  } catch (FileAlreadyExistsException e) {
    if (counter >= 999) throw e; // Give up after 1000 increments.
    moveIncremental(sourceFile, targetDir, prefix, suffix, counter + 1);
  }
}

This code first just tries to move it, and responds to the error of 'no can do; there is a file already there' and then breaks the file into a prefix and suffix, ie something.txt becomes prefix = "something" suffix = ".txt" and will then call a helper method that tries to move it to something (1).txt , all the way up to 999.

It's just one of many ways to do this - as I said, your choice.