A Guide To NIO2 File Attribute APIs – NIO2文件属性API指南

最后修改: 2016年 12月 2日


1. Overview


In this article, we are going to explore one of the advanced features of the Java 7 NIO.2 filesystem APIs – specifically file attribute APIs.

在这篇文章中,我们将探讨Java 7 NIO.2文件系统API的一个高级功能–特别是文件属性API。

We have previously covered the File and Path APIs if you want to dig deeper into these foundational pieces first.

我们之前已经介绍了文件路径 API,如果您想先深入了解这些基础部分。

All the files required to handle filesystem operations are bundled up in the java.nio.file package:


import java.nio.file.*;

2. Basic File Attributes


Let’s start with a high-level view of the basic attributes common to all file systems – provided by the BasicFileAttributeView – which stores all mandatory and optional visible file attributes.


We can explore the basic attributes of the user home location on the current machine, by creating a path to HOME and getting it’s basic attribute view:


String HOME = System.getProperty("user.home");
Path home = Paths.get(HOME);
BasicFileAttributeView basicView = 
  Files.getFileAttributeView(home, BasicFileAttributeView.class);

After the above step, we can now read all the attributes of the path pointed to in one bulk operation:


BasicFileAttributes basicAttribs = basicView.readAttributes();

We are now in a position to explore different common attributes which we can actually use in our applications especially in conditional statements.


We can query for the size of the file from its basic attributes container:


public void givenPath_whenGetsFileSize_thenCorrect() {
    long size = basicAttribs.size();
    assertTrue(size > 0);

We can also check if it’s a directory:


public void givenPath_whenChecksIfDirectory_thenCorrect() {
    boolean isDir = basicAttribs.isDirectory();

Or a regular file:


public void givenPath_whenChecksIfFile_thenCorrect() {
    boolean isFile = basicAttribs.isRegularFile();

With Java NIO.2 we are now able to deal with symbolic links or soft links in the file system. These are files or directories which we normally call shortcuts.

通过Java NIO.2,我们现在能够处理文件系统中的符号链接或软链接。这些是文件或目录,我们通常称之为快捷方式。

To check if a file is a symbolic link:


public void givenPath_whenChecksIfSymLink_thenCorrect() {
    boolean isSymLink = basicAttribs.isSymbolicLink();

In rare cases, we can call the isOther API to check if the file belongs to none of the common categories of regular file, directory or symbolic link:

在极少数情况下,我们可以调用isOther API来检查该文件是否属于普通文件、目录或符号链接等常见类别。

public void givenPath_whenChecksIfOther_thenCorrect() {
    boolean isOther = basicAttribs.isOther();

To get the time the file was created:


FileTime created = basicAttribs.creationTime();

To get the last modified time:


FileTime modified = basicAttribs.lastModifiedTime();

And to get the last access time:


FileTime accessed = basicAttribs.lastAccessTime();

All the above examples return a FileTime object. This is a more usable abstraction than a mere timestamp.


For example, we can easily compare two file times to know which event occurred before or after the other:


public void givenFileTimes_whenComparesThem_ThenCorrect() {
    FileTime created = basicAttribs.creationTime();
    FileTime modified = basicAttribs.lastModifiedTime();
    FileTime accessed = basicAttribs.lastAccessTime();

    assertTrue(0 >= created.compareTo(accessed));
    assertTrue(0 <= modified.compareTo(created));
    assertTrue(0 == created.compareTo(created));

The compareTo API works the same way as for other comparables in Java. It returns a negative value in case the object it’s being called on is less than the argument; in our case, creation time definitely comes before access time as in the first assertion.

compareTo API的工作方式与Java中的其他比较器相同。如果被调用的对象小于参数,它就会返回一个负值;在我们的例子中,创建时间肯定在访问时间之前,就像第一个断言一样。

In the second assertion, we get a positive integer value because a modification can only be made after a creation event. And finally, it returns 0 when the times being compared are equal.


When we have a FileTime object, we can then convert it to most other units depending on our needs; days, hours, minutes, seconds, milliseconds and so on. We do this by calling the appropriate API:



We can as well print a human readable form of the file time by calling its toString API:

我们也可以通过调用其toString API来打印一个人类可读的文件时间形式。


Which prints something useful in ISO time format:



We can also change the time attributes on the view by calling its setTimes(modified, accessed, created) API. We pass in the new FileTime objects where we want to change or null where we don’t want to change.

我们还可以通过调用其 setTimes(modified, accessed, created) API来改变视图的时间属性。我们在想要改变的地方传入新的FileTime对象,在不想改变的地方传入空对象。

To change the last access time one minute into the future, we would follow these steps:


FileTime newAccessTime = FileTime.fromMillis(
  basicAttribs.lastAccessTime().toMillis() + 60000);
basicView.setTimes(null, newAccessTime , null);

This change will persist in the actual file as seen from any other application running on the machine and using the file system.


3. File Space Attributes


When you open my computer on Windows, Linux or Mac, you can usually see a graphic analysis of space information about you storage drives.


Java NIO.2 makes this kind of high-level functionality very easy. It interacts with the underlying file system to retrieve this information while we only have to call simple APIs.

Java NIO.2使这种高级功能变得非常容易。它与底层文件系统交互以检索这些信息,而我们只需要调用简单的API。

We can use the FileStore class to inspect storage drives and obtain important information such as it’s size, how much space is used and how much is still unused.


To get a FileStore instance for the location of an arbitrary file in the file system, we use the getFileStore API of Files class:

为了获得一个FileStore实例,以获得文件系统中一个任意文件的位置,我们使用Files类的getFileStore API。

Path file = Paths.get("file");
FileStore store = Files.getFileStore(file);

This FileStore instance specifically represents the file store where the specified file is located, not the file itself. To get total space:


long total = store.getTotalSpace();

To get used space:


long used = store.getTotalSpace() - store.getUnallocatedSpace();

We are less likely to follow this approach than the next.


More commonly, we are likely to get information about storage information about all file stores. To emulate my computer’s graphic drive space information in a program we can use FileSystem class to enumerate the file stores:


Iterable<FileStore> fileStores = FileSystems.getDefault().getFileStores();

We can then loop over the returned values and do whatever we need to do with the information, such as updating a graphical user interface:


for (FileStore fileStore : fileStores) {
    long totalSpace = fileStore.getTotalSpace();
    long unAllocated = fileStore.getUnallocatedSpace();
    long usable = fileStore.getUsableSpace();

Note that all the returned values are in bytes. We can convert to suitable units as well as calculating other information such as used space using basic arithmetic.


The difference between unallocated space and usable space is in accessibility to the JVM.


Usable space is the space available to the JVM while unallocated space is the available space as seen by the underlying file system. Therefore, usable space may sometimes be smaller than unallocated space.


4. File Owner Attributes


To inspect file ownership information, we use the FileOwnerAttributeView interface. It gives us a high-level view of the ownership information.


We can create a FileOwnerAttributeView object like this:


Path path = Paths.get(HOME);
FileOwnerAttributeView ownerView = Files.getFileAttributeView(
  attribPath, FileOwnerAttributeView.class);

To get the owner of the file from the above view:


UserPrincipal owner = ownerView.getOwner();

There is really nothing much we can do programmatically with the above object, apart from getting the name of the owner for some other arbitrary purpose:


String ownerName = owner.toString();

5. User Defined File Attributes


There are scenarios where the file attributes defined in the file system are not sufficient for your needs. Should you come across such a case and require to set your own attributes on a file, then the UserDefinedFileAttributeView interface will come in handy:


Path path = Paths.get("somefile");
UserDefinedFileAttributeView userDefView = Files.getFileAttributeView(
  attribPath, UserDefinedFileAttributeView.class);

To retrieve the list of user defined attributes already defined for the file represented by the above view:


List<String> attribList = userDefView.list();

To set a user-defined attribute on the file, we use the following idiom:


String name = "attrName";
String value = "attrValue";
userDefView.write(name, Charset.defaultCharset().encode(value));

When you need to access the user defined attributes, you can loop over the attribute list returned by the view and inspect them using this idiom:


ByteBuffer attrValue = ByteBuffer.allocate(userView.size(attrName));
userDefView.read(attribName, attribValue);
String attrValue = Charset.defaultCharset().decode(attrValue).toString();

To remove a user-defined attribute from the file, we simply call the delete API of the view:



6. Conclusion


In this article, we have explored some of the less commonly used features available in the Java 7 NIO.2 filesystem APIs, specifically file attribute APIs.

在这篇文章中,我们探讨了Java 7 NIO.2文件系统API中的一些不太常用的功能,特别是文件属性API。

The full source code for the examples used in this article is available in the Github project.