Shulou(Shulou.com)06/01 Report--

This article introduces the knowledge of "how to use the NIO.2 feature of Java7". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

In Java 7, functions related to file manipulation have been enhanced, that is, the contents of the new java.nio.file package, which provides functions such as file path abstraction, file directory stream, directory tree, file properties and change monitoring services, which can greatly improve our operation on files.

File path

Before Java 7, the operation of the file path is all based on string. When you use it, you need to throw a string directly into it. It is inefficient to use string operation directly. For example, if you want to concatenate the parent path and subdirectory, you can only concatenate the string. And stitching itself loses its meaning as a file path. In addition, using strings for various path operations is likely to cause various problems due to spelling mistakes.

The arrival of Java 7 makes all this different. It provides the Path interface to represent the abstraction of the path, and then provides a series of methods to manipulate the path, which makes it all so simple.

In order to create Path objects conveniently, we also provide the Paths utility class, so let's take a look at how to use it.

It all starts with Path path = Paths.get ("/ Users/darcy/java/"); getting a Path object.

Path path = Paths.get ("/ Users/darcy/java/"); System.out.println ("full path:" + path.toString ()); Path pathParent = path.getParent (); System.out.println ("parent path:" + pathParent.toString ()); Path pathRoot = path.getRoot (); System.out.println ("root directory:" + pathRoot.toString ()); int pathNameCount = path.getNameCount (); System.out.println ("directory depth:" + pathNameCount) Path pathIndex3 = path.getName (2); System.out.println ("third-level directory:" + pathIndex3); Path subPath = path.subpath (1,3); System.out.println ("first-level directory to third-level directory (left and right):" + subPath.toString ()); / / resolveSibling splicing directory Path pathResolveSibling = path.resolveSibling ("PathDemo.java") from the parent directory of the current directory; System.out.println ("parent directory start stitching parameter:" + pathResolveSibling.toString ()) / / resolve takes the current path as the parent path, and parameters as subdirectories or files Path pathResolve = Paths.get ("/ Users/darcy/java/"). Resolve ("PathDem.java"); System.out.println ("current directory spliced directory:" + pathResolve.toString ()); / / the relative path of the parameter path relative to the principal path Path path2 = Paths.get ("/ Users/darcy/") Path path3 = Paths.get ("/ Users/darcy/java/PathDemo.java"); Path path4 = path2.relativize (path3); System.out.println ("relative path:" + path4.toString ()) / * output result full path: / Users/darcy/java parent path: / Users/darcy root directory: / directory depth: 3 third-level directory: java first-level directory to third-level directory (package left does not include right): darcy/java parent directory start splicing parameters: / Users/darcy/PathDemo.java current directory stitching directory: / Users/darcy/java/PathDem.java relative path: java/PathDemo.java*/

You can see that in the above code, except for entering the path once when creating the Path object, the subsequent operations are performed using the methods in Path. Before that, you may need all kinds of string interception and splicing, which is very tedious.

File operation

Remember that when you first learned Java IO, there are many ways to copy files, but either way, it takes a lot of code to write, and you need to consider the performance of copying. Reading files, not to mention, defining various read and receive variables, various validations. It is different now, not only is it very convenient to manipulate files, but also common operations such as file copying and reading can be done one line at a time.

The use is too simple, direct code.

/ / create a file Path path = Paths.get ("test.txt"); Path pathBackup = Paths.get ("test_bak.txt"); Path pathLink = Paths.get ("test.txt.link"); Path pathDir = Paths.get ("dir") if the file does not exist; / / delete Files.deleteIfExists (path); Files.deleteIfExists (pathBackup); Files.deleteIfExists (pathLink); Files.deleteIfExists (pathDir) if it already exists / / create file writing content Path file = Files.createFile (path); Files.write (path, "follow official account: unread code" .getBytes ()); Files.write (path, System.lineSeparator (). GetBytes (), StandardOpenOption.APPEND); Files.write (path, "Welcome to add me Wechat: wn8398" .getBytes (), StandardOpenOption.APPEND); System.out.println ("create File:" + file.toString ()) / / create file link pathLink = Files.createLink (pathLink, path); System.out.println ("create file:" + pathLink.toString ()); / / create directory Path directory = Files.createDirectory (pathDir); System.out.println ("create directory:" + directory.toString ()); / / file copy Files.copy (path, pathBackup); System.out.println ("copy file:" + path + "- >" + pathBackup) ") / / read the file List lines = Files.readAllLines (pathBackup); for (String line: lines) {System.out.println ("File read:" + line);}

The above shows the file creation, deletion, writing, copying, and reading of the Files class, all with only one line of code.

File attribute

Similar to path manipulation, Java 7 also provides abstraction of file attributes, adding a series of tool classes for manipulating file attributes. This part of the code is in the java.nio.file.attribute package. It abstracts an AttributeView as the parent interface of all the property views, and then uses its subclass Fi leAttributeView to represent the file view and the subclass FileOwnerAttributeView to represent the file owner's property view. The former attributes such as file creation time, modification time, whether the directory and other information, the latter contains the relevant information of the file. To be compatible with different operating systems, Java 7 also provides different implementations, such as the DosFileAttributeView view, which is obviously prepared for the Windows operating system.

It is too easy to use, the direct code is presented.

Path path = Paths.get ("/ Users/darcy/git/jdk-feature/README.md"); BasicFileAttributeView fileAttributeView = Files.getFileAttributeView (path, BasicFileAttributeView.class); BasicFileAttributes basicFileAttributes = fileAttributeView.readAttributes (); FileTime creationTime = basicFileAttributes.creationTime (); FileTime lastModifiedTime = basicFileAttributes.lastModifiedTime (); FileTime lastAccessTime = basicFileAttributes.lastAccessTime (); System.out.println ("creation time:" + creationTime); System.out.println ("Last modified time:" + lastModifiedTime); System.out.println ("Last visit time:" + lastAccessTime) Boolean directory = basicFileAttributes.isDirectory (); boolean regularFile = basicFileAttributes.isRegularFile (); boolean symbolicLink = basicFileAttributes.isSymbolicLink (); System.out.println ("whether directory:" + directory); System.out.println ("whether normal file:" + regularFile); System.out.println ("symbolic link:" + symbolicLink); long size = basicFileAttributes.size (); System.out.println ("File size:" + size); PosixFileAttributeView linuxFileAttributeView = Files.getFileAttributeView (path, PosixFileAttributeView.class); UserPrincipal owner = linuxFileAttributeView.getOwner () System.out.println ("File ownership user:" + owner.getName ())

The sample code gets the following output after running.

Creation time: 2020-09-06T13:35:14Z Last modified time: 2020-09-06T13:35:14.649261371Z Last visit time: 2020-09-06T13:35:14.680968254Z whether directory: false is normal file: true whether symbolic link: false file size: 3636 file home user: darcy file list stream

To traverse file directories and files before Java 7, you should choose the listFiles method of the File class.

/ / Files are traversed directly without traversing subdirectories String pathString = "/ Users/darcy/project/mylab/src/main/java/com/wdbyte/java"; File file = new File (pathString); File [] listFiles = file.listFiles (); for (File tempFile: listFiles) {System.out.println ("file list:" + tempFile.getAbsolutePath ());}

This traversal method also looks very elegant, but it becomes very inefficient when faced with a large number of files. So Java 7 also improves on this by introducing the DirectoryStream file list stream. It can perform progressive file traversal, a certain number of reads at a time, reducing the performance overhead of traversal, but DirectoryStream traversal only traverses its direct directories and files, not recursively traversing subdirectories. Here is how it is ergodic.

String pathString = "/ Users/darcy/project/mylab/src/main/java/com/wdbyte/java"; / / Path traverses directly without traversing the subdirectory try (DirectoryStream directoryStream = Files.newDirectoryStream (Paths.get (pathString) {for (Path pathTemp: directoryStream) {System.out.println ("DirectoryStream:" + pathTemp) }} / / Path direct traversal mode-filter .class file try (DirectoryStream directoryStream = Files.newDirectoryStream (Paths.get (pathString), "* .java") {for (Path pathTemp: directoryStream) {System.out.println ("DirectoryStream file type is class:" + pathTemp);}}

Here is an extension, the Files class has been enhanced in Java 8, the Lambda expression of Java 8 has been introduced, the walk method has been added, and traversal files are similar (Lambda expressions are used in the following examples).

/ / traverse all directories and subdirectories Stream pathStream = Files.walk (Paths.get ("/ Users/darcy/project/mylab/src/main/java/com/wdbyte")); pathStream.forEach (pathTemp-> {System.out.println ("Stream:" + pathTemp.toString ());}) / / traverse all directories and subdirectories-filter the java file pathStream = Files.walk (Paths.get ("/ Users/darcy/project/mylab/src/main/java/com/wdbyte")); pathStream .filter (pathTemp-> pathTemp.toString (). EndsWith (".java")) .forEach (pathTemp-> {System.out.println ("Stream filter java:" + pathTemp.toString ());}); file monitoring

File monitoring, that is, you can dynamically monitor the changes of files or contents in a specified directory. There are many application scenarios, such as checking whether the class file is updated during hot deployment, or operating whenever a file comes in. Previously, you can only find changes in the file by calling listFiles in a loop and comparing it with the result of the last call, but now you can do reactive logic processing by notification, which makes it easier.

The monitored object implements the Watchable interface, and then registers with the implementation of the monitoring service WatchService interface through the register method, while specifying the type of event to monitor.

/ / create StandardWatchEventKinds.ENTRY_CREATE,//, delete StandardWatchEventKinds.ENTRY_DELETE,//, update StandardWatchEventKinds.ENTRY_MODIFY

How do you use it exactly? Use the following example to see how the code is implemented. The following code monitors the folder / Users/darcy/test. The events of interest registered are create, delete, and update operations.

WatchService watchService = FileSystems.getDefault (). NewWatchService (); Path path = Paths.get ("/ Users/darcy/test"); path.register (watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY); while (true) {WatchKey watchKey = watchService.take () / / get event type for (WatchEvent pollEvent: watchKey.pollEvents ()) {/ / specific event context information Path tempPath = (Path) pollEvent.context (); Kind kind = pollEvent.kind (); if (kind.name (). Equals (StandardWatchEventKinds.ENTRY_CREATE.name () {System.out.println ("create a file:" + tempPath.toString ()) } if (kind.name (). Equals (StandardWatchEventKinds.ENTRY_DELETE.name () {System.out.println ("deleted a file:" + tempPath.toString ());} if (kind.name () .equals (StandardWatchEventKinds.ENTRY_MODIFY.name () {System.out.println ("modified a file:" + tempPath.toString () }} / / reset must be performed after the event is processed to continue listening to the event watchKey.reset (); / / cancel monitoring / / watchKey.cancel ();}

After registering event listening, through a loop, call the take () method to get the event result, and then determine the event type for log output. I did a simple test after startup, and here is the log output.

# here is my operation ➜test pwd / Users/darcy/test➜ test touch test.txt # create file ➜test vim test.txt # modify file➜ test rm test.txt # delete file # the resulting log output creates a file: test.txt creates a file: .test.txt.swp modifies a file: test.txt deletes a file: .test.txt.swp deletes a file: test.txt

Because of the use of vim editing, temporary swp file generation and automatic deletion are also detected.

That's all for the content of "how to use the NIO.2 feature of Java7". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.