即使 file.exists()、file.canRead()、file.canWrite()、file.canExecute() 都返回 true，file.delete() 返回 false

Question

我正在尝试使用 FileOutputStream 在其中写入内容后删除一个文件。 这是我用来编写的代码：

private void writeContent(File file, String fileContent) {
    FileOutputStream to;
    try {
        to = new FileOutputStream(file);
        to.write(fileContent.getBytes());
        to.flush();
        to.close();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

正如所见，我刷新并关闭流，但是当我尝试删除时，file.delete() 返回 false。

我在删除之前检查了文件是否存在，以及：file.exists()、file.canRead()、file.canWrite() >、file.canExecute() 全部返回 true。 调用这些方法后，我尝试 file.delete() 并返回 false。

我是不是做错了什么？

Answer 1

Java 中的另一个错误。 我很少找到他们，这只是我十年职业生涯中的第二次。 正如其他人提到的，这是我的解决方案。 我没有使用过System.gc()。 但就我而言，这绝对是至关重要的。 诡异的？ 是的！

finally
{
    try
    {
        in.close();
        in = null;
        out.flush();
        out.close();
        out = null;
        System.gc();
    }
    catch (IOException e)
    {
        logger.error(e.getMessage());
        e.printStackTrace();
    }
}

Answer 2

这个伎俩竟然奏效了，真是太奇怪了。 问题是，当我之前读取文件内容时，我使用了 BufferedReader。 读完后，我关闭了缓冲区。

与此同时，我进行了切换，现在我正在使用 FileInputStream 读取内容。 读完后我也关闭了流。 现在它正在发挥作用。

问题是我对此没有解释。

我不知道 BufferedReader 和 FileOutputStream 不兼容。

Answer 3

我尝试了这个简单的事情，它似乎有效。

file.setWritable(true);
file.delete();

这个对我有用。

如果这不起作用，请尝试在 Linux 上使用 sudo 运行 Java 应用程序，在 Windows 上则以管理员身份运行。 只是为了确保 Java 有权更改文件属性。

Answer 4

在尝试删除/重命名任何文件之前，您必须确保所有读取器或写入器（例如：BufferedReader/InputStreamReader/BufferedWriter）正确关闭。

当您尝试从文件读取数据或向文件写入数据时，该文件将由进程保存，直到程序执行完成后才会释放。 如果要在程序结束之前执行删除/重命名操作，则必须使用 java.io.* 类附带的 close() 方法。

Answer 5

正如 Jon Skeet 评论的那样，您应该在 finally {...} 块中关闭文件，以确保它始终处于关闭状态。 并且，不要使用 e.printStackTrace 吞掉异常，而是简单地不捕获异常并将其添加到方法签名中。 如果您出于任何原因不能，至少这样做：

catch(IOException ex) {
    throw new RuntimeException("Error processing file XYZ", ex);
}

现在，问题#2：

如果您这样做会怎样：

...
to.close();
System.out.println("Please delete the file and press <enter> afterwards!");
System.in.read();
...

您能够删除该文件吗？

此外，文件在关闭时也会被刷新。 我使用 IOUtils.closeQuietly(...)，因此在尝试关闭文件之前，我使用刷新方法来确保文件的内容存在（IOUtils.closeQuietly 不会抛出异常）。 像这样的事情：

...
try {
    ...
    to.flush();
} catch(IOException ex) {
    throw new CannotProcessFileException("whatever", ex);
} finally {
    IOUtils.closeQuietly(to);
}

所以我知道文件的内容就在那里。 因为通常对我来说重要的是文件的内容被写入，而不是文件是否可以关闭，因此文件是否关闭实际上并不重要。 就您而言，重要的是，我建议您自己关闭文件并根据情况处理任何异常。

Answer 6

您没有理由不能删除该文件。 我想看看谁拥有这个文件。 在 unix/linux 中，您可以使用 lsof 实用程序来检查哪个进程锁定了文件。 在 Windows 中，您可以使用进程资源管理器。

对于 lsof，就像说一样简单：

lsof /path/and/name/of/the/file

对于进程资源管理器，您可以使用查找菜单并输入文件名来显示句柄，该句柄将指向锁定文件的进程。

这里有一些代码可以完成我认为您需要做的事情：

FileOutputStream to;

try {
    String file = "/tmp/will_delete.txt";
    to = new FileOutputStream(file );
    to.write(new String("blah blah").getBytes());
    to.flush();
    to.close();
    File f = new File(file);
    System.out.print(f.delete());
} catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

它在 OS X 上运行良好。我还没有在 Windows 上测试它，但我怀疑它也应该在 Windows 上运行。 我也承认在 Windows wrt 文件处理中看到了一些意外的行为。

Answer 7

如果您正在使用 Eclipse IDE，这可能意味着您在上次启动应用程序时没有关闭该文件。 当我尝试删除文件时出现相同的错误消息时，这就是原因。 看来，Eclipse IDE 在应用程序终止后不会关闭所有文件。

Answer 8

希望这会有所帮助。 我遇到了类似的问题，在我的 java 代码将内容复制到其他文件夹后，我无法删除我的文件。 经过广泛的谷歌搜索，我显式声明了每个文件操作相关的变量，并调用每个文件操作对象的 close() 方法，并将它们设置为 NULL。 然后，有一个名为 System.gc() 的函数，它将清除文件 i/o 映射（我不确定，我只是告诉网站上给出的内容）。

这是我的示例代码：

public void start() {
    File f = new File(this.archivePath + "\\" + this.currentFile.getName());
    this.Copy(this.currentFile, f);

    if(!this.currentFile.canWrite()){
        System.out.println("Write protected file " +
           this.currentFile.getAbsolutePath());

        return;
    }


    boolean ok = this.currentFile.delete();
    if(ok == false){
        System.out.println("Failed to remove " + this.currentFile.getAbsolutePath());
        return;
    }
}

private void Copy(File source, File dest) throws IOException {
    FileInputStream fin;
    FileOutputStream fout;
    FileChannel cin = null, cout = null;
    try {
        fin = new FileInputStream(source);
        cin = fin.getChannel();
        fout = new FileOutputStream(dest);
        cout = fout.getChannel();

        long size = cin.size();
        MappedByteBuffer buf = cin.map(FileChannel.MapMode.READ_ONLY, 0, size);

        cout.write(buf);
        buf.clear();
        buf = null;

        cin.close();
        cin = null;

        fin.close();
        fin = null;

        cout.close();
        cout = null;

        fout.close();
        fout = null;

        System.gc();

    } catch (Exception e){
        this.message = e.getMessage();
        e.printStackTrace();
    }
}

Answer 9

答案是当您加载文件时，您需要在任何代码行中应用“关闭”方法，这对我有用

Answer 10

ruby 中曾经存在一个问题，Windows 中的文件需要“fsync”才能在写入并关闭文件后真正能够翻转并重新读取文件。 也许这是一个类似的表现（如果是这样，我认为确实是 Windows 错误）。

Answer 11

此处列出的解决方案均不适用于我的情况。 我的解决方案是使用 while 循环，尝试删除文件，为了安全起见，限制为 5 秒（可配置）。

File f = new File("/path/to/file");

int limit = 20; //Only try for 5 seconds, for safety
while(!f.delete() && limit > 0){
    synchronized(this){
        try {
            this.wait(250); //Wait for 250 milliseconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    limit--;
}

使用上面的循环无需进行任何手动垃圾收集或将流设置为空等。

Answer 12

问题可能是文件仍然被视为由程序打开和锁定； 或者它可能是您的程序中打开它的一个组件，因此您必须确保使用 dispose() 方法来解决该问题。
即JFrame框架；
....
框架.dispose();

Answer 13

您必须关闭所有流或使用 try-with-resource 块

static public String head(File file) throws FileNotFoundException, UnsupportedEncodingException, IOException
{
    final String readLine;
    try (FileInputStream fis = new FileInputStream(file);
            InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
            LineNumberReader lnr = new LineNumberReader(isr))
    {
        readLine = lnr.readLine();
    }
    return readLine;
}

Answer 14

如果 file.delete() 发送 false 那么在大多数情况下你的 Bufferedreader 句柄将不会被关闭。 就在附近，它似乎对我来说正常工作。

Answer 15

我在 Windows 上也遇到了同样的问题。 我曾经在 scala 中逐行读取文件，

Source.fromFile(path).getLines()

现在我将其作为一个整体读取，

import org.apache.commons.io.FileUtils._

// encoding is null for platform default
val content=readFileToString(new File(path),null.asInstanceOf[String])

在读取后正确关闭文件，现在

new File(path).delete

可以正常工作。

Answer 16

对于 Eclipse/NetBeans

重新启动您的 IDE 并再次运行您的代码，这对我来说只是一个小时的挣扎后的技巧工作。

这是我的代码：

File file = new File("file-path");
if(file.exists()){
  if(file.delete()){
     System.out.println("Delete");
  }
  else{

       System.out.println("not delete");
  }
}

输出：

删除

Answer 17

可能发生这种情况的另一个极端情况是：如果您通过 URL 读取/写入 JAR 文件，然后尝试在同一 JVM 会话中删除同一文件。

File f = new File("/tmp/foo.jar");
URL j = f.toURI().toURL();

URL u = new URL("jar:" + j + "!/META-INF/MANIFEST.MF");
URLConnection c = u.openConnection();

// open a Jar entry in auto-closing manner
try (InputStream i = c.getInputStream()) {

    // just read some stuff; for demonstration purposes only
    byte[] first16 = new byte[16];
    i.read(first16);
    System.out.println(new String(first16));
}

// ...

// i is now closed, so we should be good to delete the jar; but...
System.out.println(f.delete());     // says false!

---

原因是 Java 的内部 JAR 文件处理逻辑倾向于缓存 JarFile 条目：

// inner class of `JarURLConnection` that wraps the actual stream returned by `getInputStream()`

class JarURLInputStream extends FilterInputStream {
    JarURLInputStream(InputStream var2) {
        super(var2);
    }

    public void close() throws IOException {
        try {
            super.close();
        } finally {

            // if `getUseCaches()` is set, `jarFile` won't get closed!

            if (!JarURLConnection.this.getUseCaches()) {
                JarURLConnection.this.jarFile.close();
            }
        }
    }
}

以及每个 JarFile （更确切地说，底层的 ZipFile 结构）将持有文件的句柄，从构建时直到调用 close()：

public ZipFile(File file, int mode, Charset charset) throws IOException {
    // ...

    jzfile = open(name, mode, file.lastModified(), usemmap);

    // ...
}

// ...

private static native long open(String name, int mode, long lastModified,
                                boolean usemmap) throws IOException;

此 NetBeans 问题。

---

显然有两种方法可以“修复”此问题：

• 您可以禁用 JAR 文件缓存 - 对于当前的 URLConnection 或所有未来的 URLConnection（全局）在当前 JVM 会话中：

  URL u = new URL("jar:" + j + "!/META-INF/MANIFEST.MF"); 
    URLConnection c = u.openConnection(); 
  
    // 仅适用于 c 
    c.setUseCaches(false); 
  
    // 全局；   由于某种原因这个方法不是静态的， 
    // 所以我们仍然需要通过 URLConnection 实例访问它:( 
    c.setDefaultUseCaches(false); 
    

• [黑客警告！] 使用完 JarFile 后，您可以手动将其从缓存中清除。 缓存管理器 sun.net.www.protocol.jar.JarFileFactory 是包私有的，但是一些反射魔法可以为您完成工作：

  类 JarBridge { 
  
        static void closeJar(URL url) 抛出异常 { 
  
            // JarFileFactory jarFactory = JarFileFactory.getInstance(); 
            类   jarFactoryClazz = Class.forName("sun.net.www.protocol.jar.JarFileFactory"); 
            方法 getInstance = jarFactoryClazz.getMethod("getInstance"); 
            getInstance.setAccessible(true); 
            对象 jarFactory = getInstance.invoke(jarFactoryClazz); 
  
            // JarFile jarFile = jarFactory.get(url); 
            方法 get = jarFactoryClazz.getMethod("get", URL.class); 
            get.setAccessible(true); 
            对象 jarFile = get.invoke(jarFactory, url); 
  
            // jarFactory.close(jarFile); 
            方法 close = jarFactoryClazz.getMethod("close", JarFile.class); 
            关闭.setAccessible(true); 
            //noinspection JavaReflectionInvocation 
            close.invoke(jarFactory, jarFile); 
  
            // jarFile.close(); 
            ((JarFile) jarFile).close(); 
        } 
    } 
  
    // 在你的代码中： 
  
    // i 现在已关闭，所以我们应该删除该 jar 
    JarBridge.closeJar(j); 
    System.out.println(f.delete());   // 说的是真的，唷。 
    

请注意： 所有这些基于 Java 8 代码库 (1.8.0_144)； 它们可能无法与其他/更高版本一起使用。