java删除文件夹（整个删除，Spring实现）

最新推荐文章于 2024-09-07 20:00:00 发布
最新推荐文章于 2024-09-07 20:00:00 发布
阅读量2.2k 收藏 6
点赞数 2
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013490280/article/details/103359041
版权

使用org.springframework.util.FileSystemUtils#deleteRecursively

public abstract class FilesUtils {

    public static void delFilesSpring(String filePath){

        try {
            Path path = Paths.get(filePath);
            FileSystemUtils.deleteRecursively(path);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

发现过程小记

最近在开发过程中使用了一个功能需要删除一个本地的文件夹。最开始毫不犹豫的使用了这个jdk中的这个方法java.nio.file.Files#deleteIfExists。很快写完了。

public abstract class FilesUtils {

    public static void delFilesJdk(String filePath){

        try {
            Path path = Paths.get(filePath);
            Files.deleteIfExists(path);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

但是很不幸被无情的打脸了。测试直接报错。

java.nio.file.DirectoryNotEmptyException: D:\test
 at sun.nio.fs.WindowsFileSystemProvider.implDelete(WindowsFileSystemProvider.java:266)
 at sun.nio.fs.AbstractFileSystemProvider.deleteIfExists(AbstractFileSystemProvider.java:108)
 at java.nio.file.Files.deleteIfExists(Files.java:1165)
 at com.hyl.light.util.FilesUtils.delFilesJdk(FilesUtils.java:31)
 at com.hyl.light.utils.FileDelTest.jdkDel(FileDelTest.java:17)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
 at java.lang.reflect.Method.invoke(Method.java:498)
 at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
 at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
 at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
 at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
 at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
 at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
 at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
 at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
 at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
 at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
 at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
 at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
 at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
 at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
 at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
 at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
 at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
 at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)

然后又仔细看了一下源码

/**
 * Deletes a file if it exists.
 *
 * <p> As with the {@link #delete(Path) delete(Path)} method, an
 * implementation may need to examine the file to determine if the file is a
 * directory. Consequently this method may not be atomic with respect to
 * other file system operations.  If the file is a symbolic link, then the
 * symbolic link itself, not the final target of the link, is deleted.
 *
 * <p> If the file is a directory then the directory must be empty. In some
 * implementations a directory has entries for special files or links that
 * are created when the directory is created. In such implementations a
 * directory is considered empty when only the special entries exist.
 *
 * <p> On some operating systems it may not be possible to remove a file when
 * it is open and in use by this Java virtual machine or other programs.
 *
 * @param   path
 *          the path to the file to delete
 *
 * @return  {@code true} if the file was deleted by this method; {@code
 *          false} if the file could not be deleted because it did not
 *          exist
 *
 * @throws  DirectoryNotEmptyException
 *          if the file is a directory and could not otherwise be deleted
 *          because the directory is not empty <i>(optional specific
 *          exception)</i>
 * @throws  IOException
 *          if an I/O error occurs
 * @throws  SecurityException
 *          In the case of the default provider, and a security manager is
 *          installed, the {@link SecurityManager#checkDelete(String)} method
 *          is invoked to check delete access to the file.
 */
public static boolean deleteIfExists(Path path) throws IOException {
    return provider(path).deleteIfExists(path);
}

源码很明显的指出了这里会抛出一个异常DirectoryNotEmptyException。大概意思就是如果是文件夹，同时文件夹内不是空的就会抛出这个异常。
GG。问题想的太简单了。
网上搜索了一波，想想有没有大佬已经遇见过类似的问题了。果然一波搜索就出来。大概的思路就是递归去查找文件夹下的目录一一删除。具体的代码网上有很多。不做说明了。
但是不死心的我，同时作为spring的脑残粉，我的直觉告诉我spring中肯定也有同样的问题。他们是怎么解决的呢？很开心，也很容易，我在spring找到了。
org.springframework.util.FileSystemUtils#deleteRecursively

/**
 * Delete the supplied {@link File} - for directories,
 * recursively delete any nested directories or files as well.
 * @param root the root {@code File} to delete
 * @return {@code true} if the {@code File} existed and was deleted,
 * or {@code false} it it did not exist
 * @throws IOException in the case of I/O errors
 * @since 5.0
 */
public static boolean deleteRecursively(@Nullable Path root) throws IOException {
   if (root == null) {
      return false;
   }
   if (!Files.exists(root)) {
      return false;
   }

   Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
      @Override
      public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
         Files.delete(file);
         return FileVisitResult.CONTINUE;
      }
      @Override
      public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
         Files.delete(dir);
         return FileVisitResult.CONTINUE;
      }
   });
   return true;
}

这里spring直接使用了jdk的Files.walkFileTree同时重写了SimpleFileVisitor的两个方法visitFile、postVisitDirectory。
原来是这样的：

/**
 * A simple visitor of files with default behavior to visit all files and to
 * re-throw I/O errors.
 *
 * <p> Methods in this class may be overridden subject to their general contract.
 *
 * @param   <T>     The type of reference to the files
 *
 * @since 1.7
 */

public class SimpleFileVisitor<T> implements FileVisitor<T> {
    /**
     * Initializes a new instance of this class.
     */
    protected SimpleFileVisitor() {
    }

    /**
     * Invoked for a directory before entries in the directory are visited.
     *
     * <p> Unless overridden, this method returns {@link FileVisitResult#CONTINUE
     * CONTINUE}.
     */
    @Override
    public FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs)
        throws IOException
    {
        Objects.requireNonNull(dir);
        Objects.requireNonNull(attrs);
        return FileVisitResult.CONTINUE;
    }

    /**
     * Invoked for a file in a directory.
     *
     * <p> Unless overridden, this method returns {@link FileVisitResult#CONTINUE
     * CONTINUE}.
     */
    @Override
    public FileVisitResult visitFile(T file, BasicFileAttributes attrs)
        throws IOException
    {
        Objects.requireNonNull(file);
        Objects.requireNonNull(attrs);
        return FileVisitResult.CONTINUE;
    }

    /**
     * Invoked for a file that could not be visited.
     *
     * <p> Unless overridden, this method re-throws the I/O exception that prevented
     * the file from being visited.
     */
    @Override
    public FileVisitResult visitFileFailed(T file, IOException exc)
        throws IOException
    {
        Objects.requireNonNull(file);
        throw exc;
    }

    /**
     * Invoked for a directory after entries in the directory, and all of their
     * descendants, have been visited.
     *
     * <p> Unless overridden, this method returns {@link FileVisitResult#CONTINUE
     * CONTINUE} if the directory iteration completes without an I/O exception;
     * otherwise this method re-throws the I/O exception that caused the iteration
     * of the directory to terminate prematurely.
     */
    @Override
    public FileVisitResult postVisitDirectory(T dir, IOException exc)
        throws IOException
    {
        Objects.requireNonNull(dir);
        if (exc != null)
            throw exc;
        return FileVisitResult.CONTINUE;
    }
}

原始的并没有任何操作。但是spring中的工具类重写过后提供了delete操作。

/**
 * Walks a file tree.
 *
 * <p> This method works as if invoking it were equivalent to evaluating the
 * expression:
 * <blockquote><pre>
 * walkFileTree(start, EnumSet.noneOf(FileVisitOption.class), Integer.MAX_VALUE, visitor)
 * </pre></blockquote>
 * In other words, it does not follow symbolic links, and visits all levels
 * of the file tree.
 *
 * @param   start
 *          the starting file
 * @param   visitor
 *          the file visitor to invoke for each file
 *
 * @return  the starting file
 *
 * @throws  SecurityException
 *          If the security manager denies access to the starting file.
 *          In the case of the default provider, the {@link
 *          SecurityManager#checkRead(String) checkRead} method is invoked
 *          to check read access to the directory.
 * @throws  IOException
 *          if an I/O error is thrown by a visitor method
 */
public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor)
    throws IOException
{
    return walkFileTree(start,
                        EnumSet.noneOf(FileVisitOption.class),
                        Integer.MAX_VALUE,
                        visitor);
}

/**
 * Walks a file tree.
 *
 * <p> This method walks a file tree rooted at a given starting file. The
 * file tree traversal is <em>depth-first</em> with the given {@link
 * FileVisitor} invoked for each file encountered. File tree traversal
 * completes when all accessible files in the tree have been visited, or a
 * visit method returns a result of {@link FileVisitResult#TERMINATE
 * TERMINATE}. Where a visit method terminates due an {@code IOException},
 * an uncaught error, or runtime exception, then the traversal is terminated
 * and the error or exception is propagated to the caller of this method.
 *
 * <p> For each file encountered this method attempts to read its {@link
 * java.nio.file.attribute.BasicFileAttributes}. If the file is not a
 * directory then the {@link FileVisitor#visitFile visitFile} method is
 * invoked with the file attributes. If the file attributes cannot be read,
 * due to an I/O exception, then the {@link FileVisitor#visitFileFailed
 * visitFileFailed} method is invoked with the I/O exception.
 *
 * <p> Where the file is a directory, and the directory could not be opened,
 * then the {@code visitFileFailed} method is invoked with the I/O exception,
 * after which, the file tree walk continues, by default, at the next
 * <em>sibling</em> of the directory.
 *
 * <p> Where the directory is opened successfully, then the entries in the
 * directory, and their <em>descendants</em> are visited. When all entries
 * have been visited, or an I/O error occurs during iteration of the
 * directory, then the directory is closed and the visitor's {@link
 * FileVisitor#postVisitDirectory postVisitDirectory} method is invoked.
 * The file tree walk then continues, by default, at the next <em>sibling</em>
 * of the directory.
 *
 * <p> By default, symbolic links are not automatically followed by this
 * method. If the {@code options} parameter contains the {@link
 * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then symbolic links are
 * followed. When following links, and the attributes of the target cannot
 * be read, then this method attempts to get the {@code BasicFileAttributes}
 * of the link. If they can be read then the {@code visitFile} method is
 * invoked with the attributes of the link (otherwise the {@code visitFileFailed}
 * method is invoked as specified above).
 *
 * <p> If the {@code options} parameter contains the {@link
 * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then this method keeps
 * track of directories visited so that cycles can be detected. A cycle
 * arises when there is an entry in a directory that is an ancestor of the
 * directory. Cycle detection is done by recording the {@link
 * java.nio.file.attribute.BasicFileAttributes#fileKey file-key} of directories,
 * or if file keys are not available, by invoking the {@link #isSameFile
 * isSameFile} method to test if a directory is the same file as an
 * ancestor. When a cycle is detected it is treated as an I/O error, and the
 * {@link FileVisitor#visitFileFailed visitFileFailed} method is invoked with
 * an instance of {@link FileSystemLoopException}.
 *
 * <p> The {@code maxDepth} parameter is the maximum number of levels of
 * directories to visit. A value of {@code 0} means that only the starting
 * file is visited, unless denied by the security manager. A value of
 * {@link Integer#MAX_VALUE MAX_VALUE} may be used to indicate that all
 * levels should be visited. The {@code visitFile} method is invoked for all
 * files, including directories, encountered at {@code maxDepth}, unless the
 * basic file attributes cannot be read, in which case the {@code
 * visitFileFailed} method is invoked.
 *
 * <p> If a visitor returns a result of {@code null} then {@code
 * NullPointerException} is thrown.
 *
 * <p> When a security manager is installed and it denies access to a file
 * (or directory), then it is ignored and the visitor is not invoked for
 * that file (or directory).
 *
 * @param   start
 *          the starting file
 * @param   options
 *          options to configure the traversal
 * @param   maxDepth
 *          the maximum number of directory levels to visit
 * @param   visitor
 *          the file visitor to invoke for each file
 *
 * @return  the starting file
 *
 * @throws  IllegalArgumentException
 *          if the {@code maxDepth} parameter is negative
 * @throws  SecurityException
 *          If the security manager denies access to the starting file.
 *          In the case of the default provider, the {@link
 *          SecurityManager#checkRead(String) checkRead} method is invoked
 *          to check read access to the directory.
 * @throws  IOException
 *          if an I/O error is thrown by a visitor method
 */
public static Path walkFileTree(Path start,
                                Set<FileVisitOption> options,
                                int maxDepth,
                                FileVisitor<? super Path> visitor)
    throws IOException
{
    /**
     * Create a FileTreeWalker to walk the file tree, invoking the visitor
     * for each event.
     */
    try (FileTreeWalker walker = new FileTreeWalker(options, maxDepth)) {
        FileTreeWalker.Event ev = walker.walk(start);
        do {
            FileVisitResult result;
            switch (ev.type()) {
                case ENTRY :
                    IOException ioe = ev.ioeException();
                    if (ioe == null) {
                        assert ev.attributes() != null;
                        result = visitor.visitFile(ev.file(), ev.attributes());
                    } else {
                        result = visitor.visitFileFailed(ev.file(), ioe);
                    }
                    break;

                case START_DIRECTORY :
                    result = visitor.preVisitDirectory(ev.file(), ev.attributes());

                    // if SKIP_SIBLINGS and SKIP_SUBTREE is returned then
                    // there shouldn't be any more events for the current
                    // directory.
                    if (result == FileVisitResult.SKIP_SUBTREE ||
                        result == FileVisitResult.SKIP_SIBLINGS)
                        walker.pop();
                    break;

                case END_DIRECTORY :
                    result = visitor.postVisitDirectory(ev.file(), ev.ioeException());

                    // SKIP_SIBLINGS is a no-op for postVisitDirectory
                    if (result == FileVisitResult.SKIP_SIBLINGS)
                        result = FileVisitResult.CONTINUE;
                    break;

                default :
                    throw new AssertionError("Should not get here");
            }

            if (Objects.requireNonNull(result) != FileVisitResult.CONTINUE) {
                if (result == FileVisitResult.TERMINATE) {
                    break;
                } else if (result == FileVisitResult.SKIP_SIBLINGS) {
                    walker.skipRemainingSiblings();
                }
            }
            ev = walker.next();
        } while (ev != null);
    }

    return start;
}

这样Files#walkFileTree就拥有了删除功能。就可以使用jdk中的这个方法去做文件的查找和删除。

迅速另外写了一个方法测试一波。

public abstract class FilesUtils {

    public static void delFilesSpring(String filePath){

        try {
            Path path = Paths.get(filePath);
            FileSystemUtils.deleteRecursively(path);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    
}



public class FileDelTest {

    String filePath = "D:\\test";

   @Test
    public void springDel(){
        FilesUtils.delFilesSpring(filePath);
    }

}

测试通过完美。果然‘spring’大佬还是很专业的。

ps：我使用的是Spring-5.1.6.RELEASE版本。

补充一个 RocketMQ 中的做法，递归删除。
org.apache.rocketmq.common.UtilAll#deleteFile

   public static void deleteFile(File file) {
        if (!file.exists()) {
            return;
        }
        if (file.isFile()) {
            file.delete();
        } else if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File file1 : files) {
                deleteFile(file1);
            }
            file.delete();
        }
    }
crazy-tiger
关注
专栏目录
java操作minio删除文件夹及其文件方法
洛阳泰山的博客
01-19 2万+
因java项目需求，要删除minio服务文件夹和下面的所有文件，百度了一下，没有查到有用的方法，自己也查看了minio jar包中的方法，也没发现删除文件夹的，不过，网上百度查到，只要删除文件夹下的所有文件，文件夹就自动删除了。自己也亲自验证，于是有了一个思路。 pom文件所需依赖 <!--minio--> <dependency> <groupId>io.minio</groupId>
java定时执行删除文件任务_java定时删除某个文件夹所有内容
weixin_33138675的博客
02-25 826
今天在工作中遇到了定时删除某个文件夹的所有内容的任务。完成这个任务主要有两个点：1.定时器的实现2.什么时候执行定时器的任务定时器的实现主要有4种方式：普通的thread、 TimerTask和Timer搭配、ScheduledExecutorService、quartz四中方式。这里参考了http://blog.csdn.net/haorengoodman/article/details/232...
java文件操作实现修改删除
weixin_44917105的博客
12-31 999
java文件操作实现修改删除 除去使用文件输入输出流和缓冲流实现文件的读写，修改和删除都是将文件内容全部读到内存中进行，增删改查就很容易了。 但是这样的方法不适合大数据的操作，文件一直反复的写入读出，数据太大很容易造成崩溃。 对我而言，写一个学校的java课程设计足够了。 首先读文件时，将文件一行内容以特定格式分割成几段赋给数组，数组储存文件信息，依次输出，读文件就完成了。 读出来的文件动态增长优...
java 删除文件夹下内容
11-05
java 删除指定文件夹下所有文件，使用例子 DeleteFile.delAllFile(path); path的值是D:/profile/123/
【Java】已解决：java.nio.file.DirectoryNotEmptyException
最新发布
屿小夏.的知识博客
09-07 379
为了解决该报错问题，我们可以在删除目录前，递归删除目录中的所有文件和子目录。方法删除目录时出现。为了防止意外删除非空目录，该异常被设计用来提醒开发者处理目录内容。典型场景：在一个文件管理系统中，用户希望删除一个目录，但该目录不是空的，导致抛出异常。通过上述代码，我们实现了递归删除目录及其内容，避免了。在Java编程中，当尝试删除非空目录时，可能会遇到。报错问题，确保目录删除操作的正确性和安全性。通过以上步骤和注意事项，可以有效解决。不为空时，运行该代码将会抛出。
【nio】Files删除文件目录
王佑辉的博客
01-15 641
nio Files删除文件目录。
java进阶笔记之FileSystemProvider
huitoukest的专栏
06-27 2874
简介 文件相关的操作最终通过 java.nio.file.spi.FileSystemProvider 来提供 ,其不同的底层系统有不同的实现. 此类主要定义了如何在其对应的文件系统定位和加载文件 , 以及文件中常见的删除 / 拷贝等操作 . 子孙类: AbstractFileSystemProvider / WindowsFileSystemProvider / JarFileSystemProvider / ZipFileSystemProvider 示例 import com.alibaba.fas
【笔记】使用NIO操作文件删除java.nio.file.AccessDeniedException
qiao_binma的博客
03-31 743
好吧，在我几次测试下，确实是因为这个.git的问题导致报错，其他文件夹都是可以正常删除，如果有大佬知道的话，麻烦告诉我一下。等我下次搞清楚了，我也会更新一下。代码应该是没有问题的，在上网搜的时候，都是网络传输方面，但我这暂时只是本地，到这里我恍然大悟，点掉隐藏再试试，发现还是不对，但在我手动删了这个.git文件夹后就可以了。在使用代码读取目录的适合还是正常，但到了删除的时候就出现了报错。可惜在使用管理员权限运行，还是这个报错，那说明不是这个原因。仔细看了一下报错的路径，发现.git文件夹为隐藏。
Redis如何执行批量删除
zl
03-24 2841
Redis本身不支持 del key* 这种操作，del只能是单个或多个确定的key 当某一类的key数量过多时，并且无法确定key的完整值时，可以通过以下命令进行批量删除 如果确定某个db下的所有key都需要删除的话，直接flushdb更简单，但是往往不会出现这种情况 这时就可以到服务器执行如下命令 redis-cli -a [password] -h [host] -p [p
Java 实现实时监听文件夹是否有新文件增加并上传服务器功能
08-25
在Java中实现实时监听文件夹是否有新文件增加并上传服务器的功能主要涉及到使用Java NIO包中的WatchService接口，以及利用Timer定时任务执行的机制。本文将通过实例代码展示如何结合这两种技术来达到上述功能，并将...
spring boot文件夹文件监听程序
03-13
在这个"spring boot文件夹文件监听程序"项目中，我们聚焦于利用Spring Boot实现对特定文件夹的监控，并在检测到文件变化时执行相应的操作，比如自动获取遗漏文件。下面将详细介绍这一功能的实现原理和步骤。 首先，...
java springboot 七牛云文件上传，下载，删除
04-18
本文将详细介绍如何使用Spring Boot集成七牛云服务，实现文件的上传、下载和删除功能。 首先，我们需要在Spring Boot项目中引入七牛云的SDK。在`pom.xml`文件中添加对应的Maven依赖： ```xml <groupId>...
【递归复制、删除目录(文件)】FileSystemUtils
程序员咏哥的博客
05-08 1869
spring常用工具类，引入spring即可使用 boolean deleteRecursively(@Nullable File root) 删除文件 boolean deleteSuccess = FileSystemUtils.deleteRecursively(new File("D:\\fileTest\\b\\新建文件夹\\shuihe.sql")); System.out...
IOUtils, FileUtils,FilenameUtils ,FileSystemUtils ,EndianUtils
weixin_35677874的博客
03-01 373
This package defines utility classes for working with streams, readers, writers and files. The most commonly used classes are described here: IOUtils is the most frequently used class. It provides op
Java文件删除操作File#delete()
qq_31433709的博客
07-20 1339
Java文件删除操作File#delete() 这个算是一个非常通用并且常见的API了，但是其实这个方法在删除文件的时候其实是有一些限制的。如下，我们可以看见这个API返回值代表着删除是否成功： public boolean delete() { SecurityManager security = System.getSecurityManager(); if (security != null) { security.checkDelete(path); }
本地运行Flink退出时java.nio.file.DirectoryNotEmptyException、目录没有正常删除解决方法
OkGogooXSailboat的博客
08-18 946
在开发大数据平台中的查看Flink任务的状态数据工具时，用State Process API解析保存点数据，将其从HDFS上读取出来再将其解析过后下沉到HDFS以CSV格式保存，然后由其它接口提供对这个文件的分页加载功能。解析保存点和检查点中状态数据的功能代码是集成在SailWorks生产环境中台服务和DataStudio中台服务中的，状态数据解析出来以后Flink Job相关的资源销毁，服务进程并不会退出。
java directory empty_jenkins迁移后打包出现java.nio.file.DirectoryNotEmptyExceptio
weixin_39592026的博客
03-04 974
23:01:50 由用户 admin 启动23:01:50 ln builds/lastSuccessfulBuild /root/.jenkins/jobs/test-mall/lastSuccessful failed23:01:50 java.nio.file.DirectoryNotEmptyException: /root/.jenkins/jobs/test-mall/lastSucc...
迭代删除目录
大JAVA解决方案
03-05 251
// copied from Google Guava as these methods are now deprecated // NOTE: removed the line of code documented: Symbolic links will have different canonical and absolute paths public class DirectoryUtil...
使用 tf.gfile.DeleteRecursively 时，报 FailedPreconditionError 错误
TomDog的专栏
11-29 3296
代码是这样子的：if tf.gfile.Exists('/home/sarah/data/projector/tree.py'): tf.gfile.DeleteRecursively("/home/sarah/data/projector/tree.py")执行的时候总是报以下这个错： tensorflow.python.framework.errors_impl.FailedPre
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值