JDK不同操作系统的FileSystem（Windows）中篇

最新推荐文章于 2023-03-29 00:15:00 发布
最新推荐文章于 2023-03-29 00:15:00 发布
阅读量267 收藏 1
点赞数 1
文章标签： 操作系统 java
原文链接：https://juejin.im/post/5a1222c951882560e3563aa2
版权

前言

我们知道不同的操作系统有各自的文件系统，这些文件系统又存在很多差异，而Java 因为是跨平台的，所以它必须要统一处理这些不同平台文件系统之间的差异，才能往上提供统一的入口。

关于FileSystem类

JDK 里面抽象出了一个 FileSystem 来表示文件系统，不同的操作系统通过继承该类实现各自的文件系统，比如 Windows NT/2000 操作系统则为 WinNTFileSystem，而 unix-like 操作系统为 UnixFileSystem。

需要注意的一点是，WinNTFileSystem类 和 UnixFileSystem类并不是在同一个 JDK 里面，也就是说它们是分开的，你只能在 Windows 版本的 JDK 中找到 WinNTFileSystem，而在 Linux 版本的 JDK 中找到 UnixFileSystem，同样地，其他操作系统也有自己的文件系统实现类。

这里分成两个系列分析 JDK 对两种（Windows 和Linux）操作系统的文件系统的实现类，先讲 Windows操作系统，对应为 WinNTFileSystem 类。 由于篇幅较长，《JDK不同操作系统的FileSystem（Windows）》分为上中下篇，此为中篇。

继承结构

--java.lang.Object
  --java.io.FileSystem
    --java.io.WinNTFileSystem复制代码

getDefaultParent方法

返回默认的父路径，直接返回 slash 即\。

public String getDefaultParent() {
        return ("" + slash);
    }复制代码

fromURIPath方法

该方法主要是格式化路径。主要逻辑是完成类似以下的转换处理：

  1. /c:/test --> c:/test。
  2. c:/test/ --> c:/test，但要注意，c:/ --> c:/，这是通过长度来限制的，即当长度超过3时才会去掉尾部的 /。
  3. /test/ --> /test。
public String fromURIPath(String path) {
        String p = path;
        if ((p.length() > 2) && (p.charAt(2) == ':')) {
            p = p.substring(1);
            if ((p.length() > 3) && p.endsWith("/"))
                p = p.substring(0, p.length() - 1);
        } else if ((p.length() > 1) && p.endsWith("/")) {
            p = p.substring(0, p.length() - 1);
        }
        return p;
    }复制代码

isAbsolute方法

判断文件是否是绝对路径，先获取文件路径头部长度，如果长度为3则为绝对路径，如果长度为2且路径第一个字符为\也为绝对路径。

    public boolean isAbsolute(File f) {
        int pl = f.getPrefixLength();
        return (((pl == 2) && (f.getPath().charAt(0) == slash))
                || (pl == 3));
    }复制代码

canonicalize方法

该方法用来标准化一个路径，标准路径不仅是一个绝对路径而且还是唯一的路径，而且标准的定义是依赖于操作系统的，一般在标准化路径时会先将路径转成绝对路径，然后才根据操作系统解析成唯一形式的路径。这个过程比较典型的就是处理包含"."或".."的路径，还有符号链接和驱动盘符号大小写等。

  1. 如果路径长度为2，且路径第一个字符为字母，且路径第二个字符为:，此时路径类似为c:，直接返回路径或加上:返回。
  2. 如果路径长度为3，且路径第一个字符为字母，且路径第二个字符为:，且路径第三个字符为\，此时路径类似为c:\，直接返回路径或加上:返回。
  3. 如果不使用缓存则直接调用 canonicalize0 本地方法获取标准化路径。
  4. 如果使用了缓存则在缓存中查找，存在则直接返回，否则先调用 canonicalize0 本地方法获取标准化路径，再将路径放进缓存中。
  5. 另外，还提供了前缀缓存可以使用，它缓存了标准路径的父目录，这样就可以节省了前缀部分的处理，前缀缓存的逻辑也是第一次标准化后将其缓存起来，下次则可从前缀缓存中查询。
  6. 使用前缀缓存来标准化路径时是调用 canonicalizeWithPrefix 方法的，该方法最终也是调一个本地方法 canonicalizeWithPrefix0，这里不再列出该方法代码，此本地方法与前面的 canonicalize0 方法的逻辑差不多，唯一不同的是它不用遍历整个路径从头开始检查路径的有效性，而只需要检查一次整个路径的有效性，这也是存在前缀缓存的原因，节省了一些工作。
    public String canonicalize(String path) throws IOException {
        int len = path.length();
        if ((len == 2) &&
            (isLetter(path.charAt(0))) &&
            (path.charAt(1) == ':')) {
            char c = path.charAt(0);
            if ((c >= 'A') && (c <= 'Z'))
                return path;
            return "" + ((char) (c-32)) + ':';
        } else if ((len == 3) &&
                   (isLetter(path.charAt(0))) &&
                   (path.charAt(1) == ':') &&
                   (path.charAt(2) == '\\')) {
            char c = path.charAt(0);
            if ((c >= 'A') && (c <= 'Z'))
                return path;
            return "" + ((char) (c-32)) + ':' + '\\';
        }
        if (!useCanonCaches) {
            return canonicalize0(path);
        } else {
            String res = cache.get(path);
            if (res == null) {
                String dir = null;
                String resDir = null;
                if (useCanonPrefixCache) {
                    dir = parentOrNull(path);
                    if (dir != null) {
                        resDir = prefixCache.get(dir);
                        if (resDir != null) {
                            String filename = path.substring(1 + dir.length());
                            res = canonicalizeWithPrefix(resDir, filename);
                            cache.put(dir + File.separatorChar + filename, res);
                        }
                    }
                }
                if (res == null) {
                    res = canonicalize0(path);
                    cache.put(path, res);
                    if (useCanonPrefixCache && dir != null) {
                        resDir = parentOrNull(res);
                        if (resDir != null) {
                            File f = new File(res);
                            if (f.exists() && !f.isDirectory()) {
                                prefixCache.put(dir, resDir);
                            }
                        }
                    }
                }
            }
            return res;
        }
    }

private native String canonicalize0(String path)
            throws IOException;

private String canonicalizeWithPrefix(String canonicalPrefix,
            String filename) throws IOException
    {
        return canonicalizeWithPrefix0(canonicalPrefix,
                canonicalPrefix + File.separatorChar + filename);
    }


private native String canonicalizeWithPrefix0(String canonicalPrefix,
            String pathWithCanonicalPrefix)
            throws IOException;复制代码

因为标准化的具体实现是依赖于操作系统的，所以这部分工作交由本地方法去做，主要逻辑如下，

  • 标准路径最大长度是 MAX_PATH_LENGTH 即1024个字符。
  • 获取路径长度并且通过 currentDirLength 函数获取当前工作目录长度，该函数代码不再贴出来，主要逻辑是判断是否为驱动盘相对路径，如果是的话则根据驱动盘符号获取对应驱动盘的工作目录并返回该目录长度。否则就根据C的API函数 _wgetcwd 获取工作目录并返回长度。路径长度加上工作目录长度则为总长度。
  • 通过 malloc 分配空间，注意这里是宽字符。
  • 最后通过 wcanonicalize 函数标准化路径。代码较长，不再贴出，主要逻辑是，
  1. 检查路径是否包含通配符，是则标准化失败。
  2. 通过 _wfullpath 函数获取绝对路径，这个函数他会处理 \和..等符号，比如 "test"、"\test" 和"..\test"，则会处理成"C:\Documents and Settings\user\My Documents\test"、"C:\test"和"C:\Documents and Settings\user\test"。
  3. 检查路径中是否包含了非法的 .。
  4. 获取标准化驱动盘符号，将其大写，保存到结果字符数组中。
  5. 如果是 UNC 路径的话，UNC路径格式如\\server\share\file_path，则此时分别获取 server 和 share，将其保存到结果字符数组中。
  6. 通过循环检测剩余路径的有效性，主要是使用 FindFirstFileW 函数获取路径对应文件的属性信息，根据返回值可判断其有效性，有效地路径则保存到结果字符数组中。
  7. 最终结果字符数组则为标准化后的路径。
JNIEXPORT jstring JNICALL
Java_java_io_WinNTFileSystem_canonicalize0(JNIEnv *env, jobject this,
                                           jstring pathname)
{
    jstring rv = NULL;
    WCHAR canonicalPath[MAX_PATH_LENGTH];

    WITH_UNICODE_STRING(env, pathname, path) {
        int len = (int)wcslen(path);
        len += currentDirLength(path, len);
        if (len  > MAX_PATH_LENGTH - 1) {
            WCHAR *cp = (WCHAR*)malloc(len * sizeof(WCHAR));
            if (cp != NULL) {
                if (wcanonicalize(path, cp, len) >= 0) {
                    rv = (*env)->NewString(env, cp, (jsize)wcslen(cp));
                }
                free(cp);
            }
        } else
        if (wcanonicalize(path, canonicalPath, MAX_PATH_LENGTH) >= 0) {
            rv = (*env)->NewString(env, canonicalPath, (jsize)wcslen(canonicalPath));
        }
    } END_UNICODE_STRING(env, path);
    if (rv == NULL) {
        JNU_ThrowIOExceptionWithLastError(env, "Bad pathname");
    }
    return rv;
}复制代码

getBooleanAttributes方法

这是一个本地方法，它主要的作用是可以用来判断 File 对象对应的文件或目录是否存在，判断 File 对象对应的是不是文件，判断 File 对象对应的是不是目录，判断 File 对象是不是隐藏文件或目录。

但这里为什么返回的是一个 int 类型呢？因为这里为了高效利用数据，用位作为不同属性的标识，分别为
0x01、0x02、0x04、0x08，分别代表是否存在、是否为文件、是否为目录和是否为隐藏文件或目录。

public native int getBooleanAttributes(File f);复制代码

本地方法的主要逻辑是先得到文件的路径，再判断路径是否为 windows 保留设备名称，它包括以下这些，

static WCHAR* ReservedDEviceNames[] = {
    L"CON", L"PRN", L"AUX", L"NUL",
    L"COM1", L"COM2", L"COM3", L"COM4", L"COM5", L"COM6", L"COM7", L"COM8", L"COM9",
    L"LPT1", L"LPT2", L"LPT3", L"LPT4", L"LPT5", L"LPT6", L"LPT7", L"LPT8", L"LPT9",
    L"CLOCK$"
};复制代码

接着通过 GetFileAttributesExW 函数获取文件属性，如果文件属于超链接或者快捷方式，则需要再通过 CreateFileW 函数与 GetFileInformationByHandle 函数组合获取文件信息，其中 CreateFileW 函数要使用 OPEN_EXISTING 表示仅仅打开文件而不是创建。得到文件属性后通过位的或操作来标识是否存在、是否文件、是否目录、是否隐藏。

此外有一个特例也需要处理，就是 pagefile.sys 文件，它比较特殊，主要用于虚拟内存，它是文件而不是目录。

JNIEXPORT jint JNICALL
Java_java_io_WinNTFileSystem_getBooleanAttributes(JNIEnv *env, jobject this,
                                                  jobject file)
{

    jint rv = 0;
    jint pathlen;

#define SPECIALFILE_NAMELEN 12

    WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
    WIN32_FILE_ATTRIBUTE_DATA wfad;
    if (pathbuf == NULL)
        return rv;
    if (!isReservedDeviceNameW(pathbuf)) {
        if (GetFileAttributesExW(pathbuf, GetFileExInfoStandard, &wfad)) {
            DWORD a = getFinalAttributesIfReparsePoint(pathbuf, wfad.dwFileAttributes);
            if (a != INVALID_FILE_ATTRIBUTES) {
                rv = (java_io_FileSystem_BA_EXISTS
                    | ((a & FILE_ATTRIBUTE_DIRECTORY)
                        ? java_io_FileSystem_BA_DIRECTORY
                        : java_io_FileSystem_BA_REGULAR)
                    | ((a & FILE_ATTRIBUTE_HIDDEN)
                        ? java_io_FileSystem_BA_HIDDEN : 0));
            }
        } else { 
            if (GetLastError() == ERROR_SHARING_VIOLATION) {
                rv = java_io_FileSystem_BA_EXISTS;
                if ((pathlen = (jint)wcslen(pathbuf)) >= SPECIALFILE_NAMELEN &&
                    (_wcsicmp(pathbuf + pathlen - SPECIALFILE_NAMELEN,
                              L"pagefile.sys") == 0) ||
                    (_wcsicmp(pathbuf + pathlen - SPECIALFILE_NAMELEN,
                              L"hiberfil.sys") == 0))
                  rv |= java_io_FileSystem_BA_REGULAR;
            }
        }
    }
    free(pathbuf);
    return rv;
}复制代码

checkAccess方法

这是一个本地方法，它主要的作用是判断某个文件或目录是否可读、是否可写、是否可执行。这里同样用位标识这些属性，分别用0x01、0x02、0x04表示可执行、可写、可读。

public native boolean checkAccess(File f, int access);复制代码

本地方法的逻辑是先获取文件或目录路径，接着通过 GetFileAttributesW 函数获取文件属性，如果文件属于超链接或者快捷方式，则需要再通过 CreateFileW 函数与 GetFileInformationByHandle 函数组合获取文件信息，其中 CreateFileW 函数要使用 OPEN_EXISTING 表示仅仅打开文件而不是创建。可以看到如果为 INVALID_FILE_ATTRIBUTES 则是获取失败了，此时任何权限都是没有的。获取成功则当判断可读性和可执行性时都返回true，但检查可写时则还要判断是否为目录（目录直接可写），而且还要看文件属性是否为 FILE_ATTRIBUTE_READONLY，只读的话则不可写。

JNIEXPORT jboolean
JNICALL Java_java_io_WinNTFileSystem_checkAccess(JNIEnv *env, jobject this,
                                                 jobject file, jint access)
{
    DWORD attr;
    WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
    if (pathbuf == NULL)
        return JNI_FALSE;
    attr = GetFileAttributesW(pathbuf);
    attr = getFinalAttributesIfReparsePoint(pathbuf, attr);
    free(pathbuf);
    if (attr == INVALID_FILE_ATTRIBUTES)
        return JNI_FALSE;
    switch (access) {
    case java_io_FileSystem_ACCESS_READ:
    case java_io_FileSystem_ACCESS_EXECUTE:
        return JNI_TRUE;
    case java_io_FileSystem_ACCESS_WRITE:
        if ((attr & FILE_ATTRIBUTE_DIRECTORY) ||
            (attr & FILE_ATTRIBUTE_READONLY) == 0)
            return JNI_TRUE;
        else
            return JNI_FALSE;
    default:
        assert(0);
        return JNI_FALSE;
    }
}复制代码

getLastModifiedTime方法

该方法用于获取文件或目录的最后修改时间，本地方法先获取 File 对象的路径，再通过 CreateFileW 函数和 GetFileTime 函数获取最后修改时间，其中 CreateFileW 函数要使用 OPEN_EXISTING 表示仅仅打开文件而不是创建。

public native long getLastModifiedTime(File f);

JNIEXPORT jlong JNICALL
Java_java_io_WinNTFileSystem_getLastModifiedTime(JNIEnv *env, jobject this,
                                                 jobject file)
{
    jlong rv = 0;
    LARGE_INTEGER modTime;
    FILETIME t;
    HANDLE h;
    WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
    if (pathbuf == NULL)
        return rv;
    h = CreateFileW(pathbuf,
                    0,
                    FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_BACKUP_SEMANTICS,
                    NULL);
    if (h != INVALID_HANDLE_VALUE) {
        if (GetFileTime(h, NULL, NULL, &t)) {
            modTime.LowPart = (DWORD) t.dwLowDateTime;
            modTime.HighPart = (LONG) t.dwHighDateTime;
            rv = modTime.QuadPart / 10000;
            rv -= 11644473600000;
        }
        CloseHandle(h);
    }
    free(pathbuf);
    return rv;
}复制代码

getLength方法

该方法御用获取文件或目录的长度。逻辑为，

  1. 获取 File 对象的路径。
  2. 通过 GetFileAttributesExW 函数获取文件属性，然后通过 nFileSizeHigh 和 nFileSizeLow 得到文件的长度。
  3. 如果文件属于超链接或者快捷方式，则需要再通过 CreateFileW 函数与 GetFileInformationByHandle 函数组合获取文件信息，其中 CreateFileW 函数要使用 OPEN_EXISTING 表示仅仅打开文件而不是创建，然后通过 nFileSizeHigh 和 nFileSizeLow 得到文件的长度。
  4. 如果另一个进程在使用文件，则不能访问该文件，并报错 ERROR_SHARING_VIOLATION，此时尝试用 _wstati64 函数获取文件的长度。
 public native long getLength(File f);

JNIEXPORT jlong JNICALL
Java_java_io_WinNTFileSystem_getLength(JNIEnv *env, jobject this, jobject file)
{
    jlong rv = 0;
    WIN32_FILE_ATTRIBUTE_DATA wfad;
    WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
    if (pathbuf == NULL)
        return rv;
    if (GetFileAttributesExW(pathbuf,
                             GetFileExInfoStandard,
                             &wfad)) {
        if ((wfad.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0) {
            rv = wfad.nFileSizeHigh * ((jlong)MAXDWORD + 1) + wfad.nFileSizeLow;
        } else {
            BY_HANDLE_FILE_INFORMATION finfo;
            if (getFileInformation(pathbuf, &finfo)) {
                rv = finfo.nFileSizeHigh * ((jlong)MAXDWORD + 1) +
                    finfo.nFileSizeLow;
            }
        }
    } else {
        if (GetLastError() == ERROR_SHARING_VIOLATION) {
            struct _stati64 sb;
            if (_wstati64(pathbuf, &sb) == 0) {
                rv = sb.st_size;
            }
        }
    }
    free(pathbuf);
    return rv;
}复制代码

setPermission方法

该方法主要用于设置 File 对象的访问权限。逻辑如下，

  1. 如果设置额权限为 ACCESS_READ 或 ACCESS_EXECUTE，则直接返回传入的参数enable。
  2. 获取 File 对象的路径。
  3. 通过 GetFileAttributesW 函数获取文件属性。
  4. 如果文件属于超链接或者快捷方式，则先获取对应的最终路径，然后再用 GetFileAttributesW 函数获取文件属性。
  5. 判断如果不是目录的话则根据传入的参数enable设置属性，并且通过 SetFileAttributesW 函数设置文件的读写权限。
public native boolean setPermission(File f, int access, boolean enable,
            boolean owneronly);

JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_setPermission(JNIEnv *env, jobject this,
                                           jobject file,
                                           jint access,
                                           jboolean enable,
                                           jboolean owneronly)
{
    jboolean rv = JNI_FALSE;
    WCHAR *pathbuf;
    DWORD a;
    if (access == java_io_FileSystem_ACCESS_READ ||
        access == java_io_FileSystem_ACCESS_EXECUTE) {
        return enable;
    }
    pathbuf = fileToNTPath(env, file, ids.path);
    if (pathbuf == NULL)
        return JNI_FALSE;
    a = GetFileAttributesW(pathbuf);

    if ((a != INVALID_FILE_ATTRIBUTES) &&
        ((a & FILE_ATTRIBUTE_REPARSE_POINT) != 0))
    {
        WCHAR *fp = getFinalPath(env, pathbuf);
        if (fp == NULL) {
            a = INVALID_FILE_ATTRIBUTES;
        } else {
            free(pathbuf);
            pathbuf = fp;
            a = GetFileAttributesW(pathbuf);
        }
    }
    if ((a != INVALID_FILE_ATTRIBUTES) &&
        ((a & FILE_ATTRIBUTE_DIRECTORY) == 0))
    {
        if (enable)
            a =  a & ~FILE_ATTRIBUTE_READONLY;
        else
            a =  a | FILE_ATTRIBUTE_READONLY;
        if (SetFileAttributesW(pathbuf, a))
            rv = JNI_TRUE;
    }
    free(pathbuf);
    return rv;
}复制代码

以下是广告和相关阅读

========广告时间========

鄙人的新书《Tomcat内核设计剖析》已经在京东销售了，有需要的朋友可以到 item.jd.com/12185360.ht… 进行预定。感谢各位朋友。

为什么写《Tomcat内核设计剖析》

=========================

相关阅读：

JDK不同操作系统的FileSystem（Windows）上篇

欢迎关注：

这里写图片描述

这里写图片描述

weixin_34124577
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDK7新特性--NIO2.0 文件系统
jiutianhe的专栏
05-12 1820
主要包括： FileSystem 提供了许多方法来获得当前文件系统的相关信息。         Path 处理路径(文件和目录)，包括 创建path，Paths.get(String s) 获得path的详细信息 getName(),getXX()… 删除path的冗余信息 toRealPath 转换path toAbsolutePath() 合并两个path r
JDK不同操作系统的FileSystem（Windows）上篇
weixin_34331102的博客
11-13 182
前言我们知道不同的操作系统有各自的文件系统，这些文件系统又存在很多差异，而Java 因为是跨平台的，所以它必须要统一处理这些不同平台文件系统之间的差异，才能往上提供统一的入口。 关于FileSystem类JDK 里面抽象出了一个 FileSystem 来表示文件系统，不同的操作系统通过继承该类实现各自的文件系统，比如 Windows NT/2000 操作系统则为 WinNTFileSystem，而...
JDK不同操作系统的FileSystem（Windows&Unix-like）
weixin_34279061的博客
12-12 93
前言 我们知道不同的操作系统有各自的文件系统，这些文件系统又存在很多差异，而Java 因为是跨平台的，所以它必须要统一处理这些不同平台文件系统之间的差异，才能往上提供统一的入口。 关于FileSystem类 JDK 里面抽象出了一个 FileSystem 来表示文件系统，不同的操作系统通过继承该类实现各自的文件系统，比如 Windows NT/2000 操作系统则为 WinNTFileSystem...
java filesystem_JDK不同操作系统的FileSystem（unix-like）上篇
weixin_34979632的博客
03-04 633
前言我们知道不同的操作系统有各自的文件系统，这些文件系统又存在很多差异，而Java 因为是跨平台的，所以它必须要统一处理这些不同平台文件系统之间的差异，才能往上提供统一的入口。关于FileSystem类JDK 里面抽象出了一个 FileSystem 来表示文件系统，不同的操作系统通过继承该类实现各自的文件系统，比如 Windows NT/2000 操作系统则为 WinNTFileSystem，而 ...
JDK1.8 windows操作系统版本
11-06
**JDK 1.8 for Windows操作系统** Java Development Kit（JDK）是Oracle公司发布的用于开发和运行Java应用程序的重要工具集。JDK 1.8是Java语言的一个重要版本，它引入了许多新特性，优化了性能，并且为开发者提供...
32位操作系统的jdk1.8版本
07-09
Java Development Kit (JDK) 1.8 是Java编程语言的一个重要版本，尤其对于32位操作系统用户来说，它是开发和运行Java应用程序的基础。在这个版本中，Java引入了许多新特性和改进，使得开发者能够更高效地编写代码并...
JDK8、JDK17的Windows操作系统的安装包
最新发布
08-02
这里主要提供JDK8、JDK17的Windows操作系统的安装包，方便不想注册Oracle账户的对Java感兴趣的用户和Java开发从业者选择和下载。 JDK（Java Development Kit）是Java开发工具包的简称，是一套用于开发、编译、调试和...
jdk-8u281-windows-x64.exe
04-26
资源描述：jdk-8u281-windows-x64.exe是Java开发工具包（JDK）的一个版本，适用于Windows 64位操作系统。JDK是Java开发的核心工具包，包括Java编译器、Java虚拟机、Java类库等，是Java开发的必备工具。 该软件安装...
JDK1.8 windows zip解压缩版
07-26
JDK1.8 Windows Zip解压缩版是一款专为Windows操作系统设计的Java Development Kit（Java开发工具包）的非安装版本，它以ZIP压缩格式提供，方便用户下载后直接解压使用，无需经过传统的安装过程。这个版本特别适合...
文件系统（File System）
飞鹤的程序员人生
03-29 3199
文件系统是操作系统中用于管理存储设备上的分区和文件的方法和数据结构。随着存储设备的升级发展，与其相应的文件系统也在不停地发展。
java filesystem filestore path_LearningJDK/WindowsFileSystem.java at master · KennyWZhang/LearningJD...
weixin_29001327的博客
02-27 152
/** Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.** This code is free software; you can redistribute it an...
jdk1.8 java.io.File类源码阅读
weixin_42955916的博客
02-14 880
public class File implements Serializable, Comparable<File> 实现了序列化和内部比较器Comparable. 内部比较方法 public int compareTo(File pathname) { return fs.compare(this, pathname); } private s...
at java.io.WinNTFileSystem.createFileExclusively(Native Method)
chenyuezi2033的博客
08-30 2695
出现这个错误是因为使用mkdir()来创建目录，改为mkdirs（）即可 转载于:https://my.oschina.net/u/2511906/blog/3100061...
Java8 File / FileSystem（一） 源码解析
菜鸟进阶之路
06-25 4206
目录 1、separator /pathSeparatorChar 2、构造方法 3、isAbsolute /getAbsolutePath /getCanonicalPath 4、exists /isDirectory /isFile /isHidden /lastModified /length 5、createNewFile /createTempFile /delete /deleteOnExit 6、mkdir /mkdirs 7、list /list...
FileSystem类的方法使用
阿生
09-05 1万+
由于经常使用FileSystem这个类，但是对这个类的API不是很熟悉导致了一些不必要的麻烦，所以本人翻译了一下这个类。所属的包： org.apache.hadoop.fs FileSystem –>通用文件系统的抽象基类，可以作为一个分布式文件系统的实现，也可以作为连接本地磁盘的文件系统 本地版存在于小型的hadoop实例和测试中。 所有可能用到分布式文件系统的用户代码都因该使用File
JAVA中如何将File::lastModified()日期转换为常规日期
热门推荐
komtao520的博客
11-19 1万+
具体代码如下： File file=new File("d:/test"); if (file.exists()) { java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); String dateTime=df.format(new Date(file.last
windows操作系统,需要jdk17 版本
07-15
2. 在页面中找到并下载适合你的操作系统的 JDK 17 安装包（通常是 Windows x64 版本）。 3. 双击下载的安装包，运行安装程序。 4. 在安装向导中，选择你希望安装 JDK 的目标文件夹，并点击 "Next" 继续。 5. 稍后...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值