一、基础：File
1.1 构造方法：
1、 public File(String pathname) ：通过给定的路径来创建新的 File实例。
2、 public File(String parent, String child) ：从父路径(字符串)和子路径创建新的 File实例。
3、 public File(File parent, String child) ：从父路径(File)和子路径名字符串创建新的 File实例。
// 文件路径名
String path = "D:\\123.txt";
File file1 = new File(path);
// 文件路径名
String path2 = "D:\\1\\2.txt";
File file2 = new File(path2); // -------------相当于D:\\1\\2.txt
// 通过父路径和子路径字符串
String parent = "F:\\aaa";
String child = "bbb.txt";
File file3 = new File(parent, child); //--------相当于F:\\aaa\\bbb.txt
// 通过父级File对象和子路径字符串
File parentDir = new File("F:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);// --------相当于F:\\aaa\\bbb.txt
1.2 获取
1、public String getAbsolutePath() ：返回此File的绝对路径。
2、public String getPath() ：结果和getAbsolutePath一致。
3、public String getName() ：返回文件名或目录名。
4、public long length() ：返回文件长度，以字节为单位。
public class FileGet {
public static void main(String[] args) {
File f = new File("d:/aaa/bbb.java");
System.out.println("文件绝对路径:"+f.getAbsolutePath());
System.out.println("文件构造路径:"+f.getPath());
System.out.println("文件名称:"+f.getName());
System.out.println("文件长度:"+f.length()+"字节");
File f2 = new File("d:/aaa");
System.out.println("目录绝对路径:"+f2.getAbsolutePath());
System.out.println("目录构造路径:"+f2.getPath());
System.out.println("目录名称:"+f2.getName());
System.out.println("目录长度:"+f2.length());
}
}
1.3 判断
1、 public boolean exists() ：判断文件或目录是否存在。
2、 public boolean isDirectory() ：判断是否为目录。
3、public boolean isFile() ：判断是否为文件。
public class FileIs {
public static void main(String[] args) {
File f = new File("d:\\aaa\\bbb.java");
File f2 = new File("d:\\aaa");
// 判断是否存在
System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
System.out.println("d:\\aaa 是否存在:"+f2.exists());
// 判断是文件还是目录
System.out.println("d:\\aaa 文件?:"+f2.isFile());
System.out.println("d:\\aaa 目录?:"+f2.isDirectory());
}
}
1.4 创建、删除功能的方法
public boolean createNewFile() ：文件不存在，创建一个新的空文件并返回true，文件存在，不创建文件并返回false。
public boolean delete() ：删除文件或目录。
public boolean mkdir() ：创建目录。
public boolean mkdirs() ：创建目录，包括任何必需但不存在的父目录。
mkdir()，只能创建一级目录，
mkdirs()可以创建多级目录比如//a//b//c，所以开发中一般用mkdirs();
public class FileCreateDelete {
public static void main(String[] args) throws IOException {
// 文件的创建
File f = new File("aaa.txt");
System.out.println("是否存在:"+f.exists()); // false
System.out.println("是否创建:"+f.createNewFile()); // true
System.out.println("是否创建:"+f.createNewFile()); // 以及创建过了所以再使用createNewFile返回false
System.out.println("是否存在:"+f.exists()); // true
// 目录的创建
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
// 创建多级目录
File f3= new File("newDira\\newDirb");
System.out.println(f3.mkdir());// false
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());// true
// 文件的删除
System.out.println(f.delete());// true
// 目录的删除
System.out.println(f2.delete());// true
System.out.println(f4.delete());// false
}
}
1.5 目录遍历
public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
注意：listFiles在获取指定目录下的文件或者文件夹时必须满足下面两个条件：
1，指定的目录必须存在
2，指定的必须是目录。否则容易引发NullPointerException异常
public class FileFor {
public static void main(String[] args) {
File dir = new File("G:\光标");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
1.6 递归遍历文件夹下所有文件以及子文件
package File;
import java.io.File;
//递归遍历文件夹下所有的文件
public class RecursionDirectory {
public static void main(String[] args) {
File file=new File("D:\\java专属IO测试");
Recursion(file);
}
public static void Recursion(File file){
//1、判断传入的是否是目录
if(!file.isDirectory()){
//不是目录直接退出
return;
}
//已经确保了传入的file是目录
File[] files = file.listFiles();
//遍历files
for (File f: files) {
//如果该目录下文件还是个文件夹就再进行递归遍历其子目录
if(f.isDirectory()){
//递归
Recursion(f);
}else {
//如果该目录下文件是个文件，则打印对应的名字
System.out.println(f.getName());
}
}
}
}
二、NIO.2
+++ Java NIO.2 的背景
1）Java NIO 基础：
Java NIO 的初衷是为了提供更高效的 I/O 操作，引入了 Channel 和 Buffer 的概念。
然而，这种基础功能并不足以满足复杂的文件系统操作需求。
2）文件操作的局限性：
Java 早期的文件操作 API（如 java.io.File 类）存在一些局限性，
如对文件属性的支持有限、无法处理符号链接等。
3）需求增加：
随着文件系统操作需求变得更加复杂，如处理文件元数据、监视文件系统变化等，
对文件操作功能的需求也逐渐增加。
4）功能改进和扩展：
为了弥补这些不足，Java 7 引入了 NIO.2，致力于提供更全面、更现代化的文件操作功能，
使得 Java 在处理文件操作时更加强大、灵活和高效。
+++ Java NIO.2
1）NIO.2（也称为Java NIO 2或Java New I/O）是Java 7中引入的一组增强的用于文件操作的API。
2）NIO.2极大地改进了Java对文件系统操作的支持，提供了更强大、更灵活和更高效的文件处理功能。
+++ Java NIO.2主要内容包括以下主要功能和组件：
以下是NIO.2 的一些主要内容和组件，它们共同构成了一个强大的文件操作框架，
为开发人员提供了更灵活、高效的文件操作能力。
1）Path：
java.nio.file.Path接口代表文件系统中的路径。
它可以指向文件或目录，并提供了许多实用方法来操作路径。
2）Paths：
java.nio.file.Paths 类包含用于获取 Path 实例的静态工厂方法。
它允许您创建 Path 对象以表示文件或目录的路径。
3）Files：
java.nio.file.Files 类提供了许多静态方法。
用于执行文件和目录操作，如复制、移动、删除、创建文件/目录、读取/写入文件等。
4）FileSystem：
java.nio.file.FileSystem 接口代表文件系统，
可以从中获取文件根目录、文件属性等信息。
5）FileSystems：
java.nio.file.FileSystems 类包含用于获取文件系统的实例的工厂方法。
您可以使用这些方法来获取默认文件系统或从URI创建文件系统。
6)WatchService：
java.nio.file.WatchService 接口允许程序监视文件系统的更改。
通过注册要监视的目录，您可以接收文件/目录创建、修改、删除等事件通知。
7)FileAttribute：
java.nio.file.attribute 包含用于表示文件属性的类和接口，
如文件的大小、权限、所有者、最后修改时间等。
三、NIO.2 – Path、Paths
1）Path：是JDK1.7中定义的接口，主要用来在文件系统中定位文件，通常表示系统相关的文件路径。
java.nio.file.Path接口代表文件系统中的路径。
它可以指向文件或目录，并提供了许多实用方法来操作路径。
2）Paths：是JDK1.7中定义的静态工具类，用来根据String格式的路径或者URI返回Path的实例。
java.nio.file.Paths 类包含用于获取 Path 实例的静态工厂方法。
它允许您创建 Path 对象以表示文件或目录的路径。
3.1 Path实例的获取
+++ Path实例的获取
Path是接口，实例不能通过new关键字直接去构建；
而Path的实现类，官方并不想暴露出来给用户使用，所以我们应该通过其他途径去获取Path的实例。
1）通过静态方法获取：可以使用 java.nio.file.Paths 类的静态方法来获取 Path 实例。例如：
Path path1 = Paths.get("path/to/file.txt"); // 根据字符串路径获取 Path 实例
Path path2 = Paths.get(URI.create("file:///path/to/file.txt")); // 根据 URI 获取 Path 实例
2）通过文件系统默认实例获取：可以通过默认文件系统获取 Path 实例。例如：
//方式一：使用默认的文件系统
Path path = FileSystems.getDefault().getPath("path/to/file.txt");
//方式二：使用非默认的文件系统，定制文件系统【用于操作非默认的文件系统】
FileSystem customFS = FileSystems.newFileSystem(URI.create("file:///customFileSystem"), new HashMap<>());
Path path = customFS.getPath("path/to/file.txt");
3）通过路径组件逐级构建：您也可以使用 Path 接口的 resolve() 方法来逐级构建路径。例如：
Path basePath = Paths.get("/base");
Path fullPath = basePath.resolve("path").resolve("to").resolve("file.txt");
4）通过File实例获取
File f = new File("d:/aaa/bbb.java");
Path path = f.toPath();
1）Path实例的获取
public static void main(String[] args) throws IOException {
//通过指定文件或目录路径获取
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\机器学习");
System.out.println(path);
//通过URI获取
URI uri = URI.create("file:///C:/Users/lenovo/Desktop/机器学习");
Path path1 = Paths.get(uri);
System.out.println(path1);
//通过默认的文件系统获取
Path path2 = FileSystems.getDefault().getPath("C:\\Users\\lenovo\\Desktop\\机器学习");
System.out.println(path2);
//通过File实例转换
File file=new File("C:\\Users\\lenovo\\Desktop\\机器学习");
Path path3 = file.toPath();
System.out.println(path3);
}
2）注意事项
>>>>> Path路径支持【…】，表示回到上一层
public static void main(String[] args) throws IOException {
//通过指定文件或目录路径获取
Path path = Paths.get("D:/Users\\lenovo\\Desktop\\..\\机器学习");
System.out.println(path);
}
>>>>> Path路径对应的目录或文件不存在，不会报错
public static void main(String[] args) throws IOException {
//通过指定文件或目录路径获取
Path path = Paths.get("D:/Users\\lenovo\\Desktop\\..\\机器学习xxx");
System.out.println(path);
}
3.2 Path的API
Path接口主要是用来管理文件路径的，所以文件路径管理涉及的主要也是Path中的方法
1）查询
path.getFileName()：
获取文件、目录或者其他类型文件的名称，返回值类型是Path。
例如对于/users/nanxs/test构造的Path实例，返回的就是test对应的Path实例。
path.getNameCount()：统计path的路径层级
path.getName(int index)：根据指定的Path层级获取
分层拆分路径。
例如对于D:/users/nanxs/test：
getNameCount()返回的就是3，
path.getName(int index)，当index分别为0~2时，得到的结果分别是users、nanxs和test。
path.getParent()：
获取文件的父路径的Path实例，
例如对于/users/nanxs/test构造的Path实例，返回的就是/users/nanxs对应的Path实例。
path.getRoot()：
获取根路径，
例如对于Linux/Mac OS，根路径一般就是"/"。
path.getFileSystem()：
获取文件系统。
path.normalize()：
规范化文件路径，去除路径中多余的部分。
对于/users/nanxs/test/../test2，规范化后得到的结果就是/users/nanxs/test2
path.iterator()：
返回迭代器，用来访问各级路径。
2）判断
path.startsWith(Path other)
path.startsWith(String other)：
判断path的是不是以other开头的。
对于/users/nanxs/test，不是start with users，而是start with "/"。
path.endsWith(Path other)
path.endsWith(String other)
判断path的是不是以other结束的。
对于/users/nanxs/test.txt，就是以test.txt结束的。
path.isAbsolute()：
判断是否是绝对路径，如果是绝对路径返回true，否则为false
（不访问文件，只看是不是绝对路径，如果是绝对路径，即使文件不存在也会返回true）。
3）判断：Path示例之间的比较
path.equals(path1)：
两个路径完全相同时才会返回true，
例如/users/nanxs/test/../test2和/users/nanxs/test2比较，得到的也是false。
path.compareTo(path1)：
两个路径完全相同时才会返回0。否则：
首先，从第一个字符开始比较，直到碰到第一个不一样的字符时，返回path的字符的ASCII码 - path1的字符的ASCII码的int值；
然后，如果直到一个path的路径的字符已经比较到最后一位了，仍然没有找到差别，此时返回path的路径长度（即字符数量）- path1的路径长度。
Files.isSameFile(path, path1)：比较两个path是否找到相同的文件。代码执行的逻辑如下：
首先，如果两个Path实例equals，则直接返回true；
然后，如果两个Path实例来自于不同的FileSystemProvider，则直接返回false；
最后，方法检查两个Path实例是否指向同一个文件。
这时，取决于该FileSystemProvider的实现类的实现，有可能会要求访问两个文件。如果去访问文件，如果文件不存在，可能产生异常。
4）其他
path.resolve(Path path1)
path.resolve(String path1)：
把当前路径当成父路径，把输入参数的路径当成子路径，得到一个新的路径。
path.relativize(path1)：
返回一个相对路径，是基于path的path1的相对路径。
例如path指定路径/users，path1指定路径/users/nanxs，那么返回的结果的路径就是nanxs。
1）查询
>>>> 示例
public static void main(String[] args) throws IOException {
//通过指定文件或目录路径获取
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\机器学习");
System.out.println(path);
Path fileName = path.getFileName();
System.out.println("获取文件名："+fileName); //获取文件名：机器学习
int nameCount = path.getNameCount();
System.out.println("统计文件目录层级："+nameCount); //统计文件目录层级：4
Path name = path.getName(0);
System.out.println("获取指定的文件目录层级："+name); //获取指定的文件目录层级：Users
Path root = path.getRoot();
System.out.println("获取文件系统根目录:"+root); //获取文件系统根目录:D:\
Path parent = path.getParent();
System.out.println("获取父级目录"+parent); //获取父级目录D:\Users\lenovo\Desktop
FileSystem fileSystem = path.getFileSystem();
System.out.println("获取文件系统："+fileSystem); //获取文件系统：sun.nio.fs.WindowsFileSystem@1d44bcfa
}
>>>> 示例：path.getNameCount（）、path.getName(n)
path.getNameCount（）：获取path的层级
path.getName(n)：指定层级，获取path
public static void main(String[] args) throws IOException {
//1、获取path层级
//在windows系统中不包含盘符
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\机器学习xxx");
int nameCount = path.getNameCount();
System.out.println(nameCount); //5
//获取Path指定的层级
Path name = path.getName(1);
System.out.println(name); //lenovo
//2、获取path层级
Path path2 = Paths.get("\\lenovo\\Desktop\\..\\机器学习xxx");
int nameCount2 = path2.getNameCount();
System.out.println(nameCount2); //4
//获取Path指定的层级
Path name2 = path2.getName(1);
System.out.println(name2); //Desktop
//3、获取path层级
Path path3 = Paths.get("lenovo\\Desktop\\..\\机器学习xxx");
int nameCount3 = path3.getNameCount();
System.out.println(nameCount3); //4
//获取Path指定的层级
Path name3 = path3.getName(1);
System.out.println(name3); //Desktop
}
>>>> 示例：path.normalize() 格式化path路径
path.normalize()：格式化path路径
public static void main(String[] args) throws IOException {
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\");
Path normalize = path.normalize();
System.out.println(normalize);
}
>>>> 示例：path.iterator() 迭代path路径
path.iterator()：迭代path的分层路径。
path的分层路径不包含盘符。
public static void main(String[] args) throws IOException {
System.out.println("=== D:\\Users\\lenovo\\Desktop\\..\\1 === ");
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\1");
Iterator<Path> iterator = path.iterator();
while(iterator.hasNext()){
Path next = iterator.next();
System.out.println(next);
}
System.out.println("=== Users\\lenovo\\Desktop\\..\\1 === ");
Path path2 = Paths.get("Users\\lenovo\\Desktop\\..\\1");
Iterator<Path> iterator2 = path2.iterator();
while(iterator2.hasNext()){
Path next = iterator2.next();
System.out.println(next);
}
}
2）判断
>>>> 示例
public static void main(String[] args) throws IOException {
//通过指定文件或目录路径获取
Path path = Paths.get("D:/Users\\lenovo\\Desktop\\..\\机器学习");
System.out.println(path);
//判断是否以指定路径开头
boolean b = path.startsWith("D:\\");
System.out.println(b); //true
boolean b1 = path.startsWith(Paths.get("d:\\"));
System.out.println(b1); //true
//判断是否以指定路径结尾
boolean b2 = path.endsWith("机器学习");
System.out.println(b2); //true
boolean b3 = path.endsWith(Paths.get("机器学习"));
System.out.println(b3); //true
//规范化路径
Path normalize = path.normalize();
System.out.println(normalize); //D:\Users\lenovo\机器学习
}
>>>> 示例：path.startsWith（）判断路径是否以某个层级开头
public static void main(String[] args) throws IOException {
//判断path是否以指定层级开头
//1、如果以盘符开头，则匹配字符串必须写全[D:\\]
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\机器学习xxx");
boolean b = path.startsWith("D:\\");
boolean b2 = path.startsWith("D:");
System.out.println(b);//true
System.out.println(b2); //false
//2、如果以[\\xxx]开头，则匹配字符串必须写全[\\xxx]
Path path3 = Paths.get("\\Users\\lenovo\\Desktop\\..\\机器学习xxx");
boolean b3 = path3.startsWith("\\Users");
boolean b4= path3.startsWith("Users");
System.out.println(b3); //true
System.out.println(b4); //false
//3、如果以[xxx]开头，则匹配字符串必须写全[xxx]
Path path4 = Paths.get("Users\\lenovo\\Desktop\\..\\机器学习xxx");
boolean b5= path4.startsWith("Users");
boolean b6 = path4.startsWith("\\Users");
System.out.println(b5); //true
System.out.println(b6); //false
}
>>>> 示例：path.isAbsolute()
path.isAbsolute() 判断路径是否绝对路径
public static void main(String[] args) throws IOException {
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\1");
Path path2 = Paths.get("\\Users\\lenovo\\1");
System.out.println(path.isAbsolute());
System.out.println(path2.isAbsolute());
}
3）判断：Path示例之间的比较
>>>> path.equals(path2)
path.equals(path2)：比较两个路径是否一致。一致返回true，不一致返回false
public static void main(String[] args) throws IOException {
Path path3 = Paths.get("D:\\Users\\lenovo\\Desktop\\1");
Path path4 = Paths.get("D:\\Users\\lenovo\\Desktop\\1");
System.out.println(path3.equals(path4)); //true
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\1");
Path path2 = Paths.get("D:\\Users\\lenovo\\1");
System.out.println(path.equals(path2)); //false
}
>>>> path.compareTo(path2)
path.compareTo(path2) ：
比较两个路径， 从左到右比较字符
如果路径完全相同，返回0。
如果路径不同，则返回不同字符的ASCII码值。
public static void main(String[] args) throws IOException {
Path path3 = Paths.get("D:\\Users\\lenovo\\Desktop\\1");
Path path4 = Paths.get("D:\\Users\\lenovo\\Desktop\\1");
System.out.println(path3.compareTo(path4)); //0
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\1");
Path path2 = Paths.get("D:\\Users\\lenovo\\1");
System.out.println(path.compareTo(path2)); //19
}
>>>> Files.isSameFile(path,path2)
Files.isSameFile(path,path2)
比较两个路径是否一致。
如果相同，返回true。
如果不同，则异常。
public static void main(String[] args) throws IOException {
Path path3 = Paths.get("D:\\Users\\lenovo\\Desktop\\1");
Path path4 = Paths.get("D:\\Users\\lenovo\\Desktop\\1");
System.out.println(Files.isSameFile(path3,path4)); //true
Path path = Paths.get("D:\\Users\\lenovo\\Desktop\\..\\1");
Path path2 = Paths.get("D:\\Users\\lenovo\\1");
System.out.println(Files.isSameFile(path,path2)); //异常
}
Java7中文件IO发生了很大的变化，专门引入了很多新的类。用来取代原来的基于java.io.File的文件IO操作方式.
import java.nio.file.DirectoryStream;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
Path用于来表示文件路径和文件。可以有多种方法来构造一个Path对象来表示一个文件路径，或者一个文件
利用Paths创建
Paths 类只有2个方法。它们是 Path 实例的工厂方法
static Path get(String first, String… more) 将路径字符串或在连接时形成路径字符串的字符串序列转换为路径。
static Path (URI uri) 将给定URI转换为路径对象。
// 使用绝对路径创建
Path absolutePath = Paths.get("D:\\test\\1.txt");
// 使用相对路径创建
Path relativePath = Paths.get("D:\\test", "1.txt");
System.out.println(absolutePath.equals(relativePath)); // ture
利用FileSystems创建
Path path3 = FileSystems.getDefault().getPath(“C:/”, “access.log”);
File和Path之间的转换，File和URI之间的转换
File file = new File("C:/my.ini");
Path p1 = file.toPath();
p1.toFile();
file.toURI();
利用URI创建
URI u = URI.create("file:///C:/Xmp/dd");
Path p = Paths.get(u);
4）其他
>>>> path.resolve(Path path1) 拼接路径
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2");
Path xx = path.resolve(Paths.get("xx\\cc"));
System.out.println(xx);
}
四、NIO.2 – Files类
java.nio.file.Files 用于操作文件或目录的工具类。
Files类只包含对文件，目录或其他类型文件进行操作的静态方法。主要和Path接口的对象进行配合使用
4.1 文件、文件夹的增删改
+++ 文件、文件夹的创建
static Path createDirectories(Path dir, FileAttribute<?>... attrs)
创建一个目录及其所有不存在的父目录。
注意：如果目录已经存在，它不会抛出异常，而是会静默地返回
static Path createDirectory(Path dir, FileAttribute<?>... attrs)
创建一个新的目录。
注意：与 Files.createDirectories() 方法不同：
1）如果指定的目录的父目录不存在，则会抛出 NoSuchFileException 异常。
2）如果目录已经存在，也会抛出 FileAlreadyExistsException 异常。
static Path createFile(Path path, FileAttribute<?>... attrs)
创建一个新的和空的文件，
注意：如果该文件已存在，则异常。
如果指定目录不存在，则异常。
+++ 文件、文件夹的复制
static Path copy(Path source, Path target, CopyOption... options)
将文件从一个位置复制到另一个位置。
默认情况下，如果文件存在，则直接覆盖。
参数：
source：要复制的源文件路径。
target：要将文件复制到的目标路径。
options：可选的复制选项，如覆盖现有目标文件、保留文件属性等。
StandardCopyOption.REPLACE_EXISTING：如果目标文件已存在，则覆盖它。
StandardCopyOption.COPY_ATTRIBUTES：复制文件属性，如权限、时间戳等。
LinkOption.NOFOLLOW_LINKS：如果源文件是符号链接，则不跟踪它。
static long copy(InputStream in, Path target, CopyOption... options)
将文件从一个位置复制到另一个位置。
默认情况下，如果文件存在，则会报错。可通过CopyOption设置
static long copy(Path source, OutputStream out)
将文件中的所有字节复制到输出流。
+++ 文件、文件夹的移动和重命名
static Path move(Path source, Path target, CopyOption... options)
将文件移动或重命名为目标文件。
注意：如果目标文件存在，则直接覆盖。
参数：
source：源文件路径。
target：目标路径。
options：可选的选项，如覆盖现有目标文件、保留文件属性等。
StandardCopyOption.REPLACE_EXISTING：如果目标文件已存在，则覆盖它。
StandardCopyOption.COPY_ATTRIBUTES：复制文件属性，如权限、时间戳等。
LinkOption.NOFOLLOW_LINKS：如果源文件是符号链接，则不跟踪它。
+++ 文件、文件夹的删除
static boolean deleteIfExists(Path path)
删除文件或目录（如果存在）。
如果文件或目录不存在或删除失败，则返回false
不能删除非空文件夹。
static void delete(Path path)
删除文件或目录。
如果文件或目录不存在或删除失败，则报错。
不能删除非空文件夹。
1）文件、文件夹的创建
>>>> createDirectories(Path dir, FileAttribute<?>… attrs) 根据path创建文件夹
创建文件夹
如果指定的目录的父目录不存在，则也会创建。
如果创建的新目录已经存在，则静默。
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2");
//创建多级别目录
Files.createDirectories(path);
}
>>>> createDirectory(Path dir, FileAttribute<?>… attrs) 根据path创建文件夹
创建新目录
如果指定的目录的父目录不存在，则报错。
如果创建的新目录已经存在，则报错
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2");
//创建
Files.createDirectory(path);
}
>>>> createFile(Path dir, FileAttribute<?>… attrs) 根据path创建文件
创建文件
如果文件的父目录不存在，则会报错。
如果文件已经存在。则会报错。
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
Files.createFile(path);
}
2）文件、文件夹的复制
>>>> copy(Path source, Path target, CopyOption… options) 根据path复制到path
复制a.txt文件，为a1.txt
public static void main(String[] args) throws IOException {
Path source = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a.txt");
Path target = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a1.txt");
Files.copy(source,target);
}
设置CopyOption
复制a.txt文件，为a1.txt。设置CopyOption参数
public static void main(String[] args) throws IOException {
Path source = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a.txt");
Path target = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a1.txt");
CopyOption[] copyOptions=new CopyOption[]{
StandardCopyOption.COPY_ATTRIBUTES,//复制文件属性
StandardCopyOption.REPLACE_EXISTING //如果文件存在，则直接覆盖
};
Files.copy(source,target,copyOptions);
}
}
>>>> copy(InputStream in, Path target, CopyOption… options) 根据输入流复制到path
复制a.txt文件，为a1.txt
public static void main(String[] args) throws IOException {
InputStream in=new FileInputStream(new File("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a.txt"));
Path target = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a1ss.txt");
Files.copy(in,target);
}
>>>> copy(Path source, OutputStream out) 根据path复制到输出流
public static void main(String[] args) throws IOException {
Path source = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a.txt");
OutputStream outputStream=new FileOutputStream(new File("C:\\Users\\lenovo\\Desktop\\新建文件夹\\aXX.txt"));
Files.copy(source,outputStream);
}
3）文件、文件夹的移动和重命名
public static void main(String[] args) throws IOException {
Path source = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a.txt");
Path target = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\a22.txt");
Files.move(source,target);
}
4）文件、文件夹的删除
public static void main(String[] args) throws IOException {
//删除文件或目录
//如果文件或目录不存在或删除失败，则返回false
//不能删除非空文件夹
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\1");
boolean b = Files.deleteIfExists(path);
System.out.println(b);
//删除文件或目录
//如果文件或目录不存在或删除失败，则返回false
//不能删除非空文件夹
Path path2 = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\1");
Files.delete(path2);
}
4.2 文件的读写
+++ 通过Files获取字节、字符输入流
static InputStream newInputStream(Path path)
打开一个文件，返回输入流以从文件中读取。
注意：如果文件不存在，则报错
static BufferedReader newBufferedReader(Path path)
static BufferedReader newBufferedReader(Path path, Charset cs)
通过path获取字符流
注意：如果文件不存在，则报错
+++ 通过Files获取字节、字符输出流
static OutputStream newOutputStream(Path path, OpenOption... options)
打开或创建文件，返回可用于向文件写入字节的输出流。
注意：1）默认情况下，创建对象时，如果文件不存在，则会创建新文件。
2）默认情况下，创建对象时，如果文件存在，则会覆盖该文件。
3）可通过设置options来控制。
参数
path: 要写入的文件的路径，类型为 Path。
options: 一个可变参数列表，指定文件打开的选项，类型为 OpenOption。常用选项包括：
StandardOpenOption.CREATE：如果文件不存在，则创建新文件。
StandardOpenOption.APPEND：将数据追加到文件末尾，而不是覆盖文件内容。
StandardOpenOption.TRUNCATE_EXISTING：如果文件存在，则截断文件（即清空文件内容）。
StandardOpenOption.WRITE：以写入模式打开文件（默认）。
static BufferedWriter newBufferedWriter(Path path, OpenOption... options)
static BufferedWriter newBufferedWriter(Path path, Charset cs, OpenOption... options)
打开或创建一个写入文件，返回一个 BufferedWriter。
注意：1）默认情况下，创建对象时，如果文件不存在，则会创建新文件。
2）默认情况下，创建对象时，如果文件存在，则会覆盖该文件。
3）可通过设置options来控制。
参数
path: 要写入的文件的路径，类型为 Path。
options: 一个可变参数列表，指定文件打开的选项，类型为 OpenOption。常用选项包括：
StandardOpenOption.CREATE：如果文件不存在，则创建新文件。
StandardOpenOption.APPEND：将数据追加到文件末尾，而不是覆盖文件内容。
StandardOpenOption.TRUNCATE_EXISTING：如果文件存在，则截断文件（即清空文件内容）。
StandardOpenOption.WRITE：以写入模式打开文件（默认）。
+++ 以下方法适用于处理中等长度的文本文件，如果要处理的文件长度比较大，或者是二进制文件，那么还是应该使用流
+++ 通过Files直接读文件
static byte[] readAllBytes(Path path)
读取文件中的所有字节。
static List<String> readAllLines(Path path)
static List<String> readAllLines(Path path, Charset cs)
从文件中读取所有行。
+++ 通过Files直接写文件
static Path write(Path path, byte[] bytes, OpenOption... options)
将字节写入文件。
static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options)
将文本行写入文件。
static Path write(Path path, Iterable<? extends CharSequence> lines, OpenOption... options)
将文本行写入文件。
+++ 其他
static SeekableByteChannel newByteChannel(Path path, OpenOption... options)
打开或创建文件，返回可访问的字节通道以访问该文件。
static SeekableByteChannel newByteChannel(Path path, Set<? extends OpenOption> options, FileAttribute<?>... attrs)
打开或创建文件，返回可访问的字节通道以访问该文件。
1）通过Files获取字节、字符输入流
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files获取字节输入流
InputStream inputStream = Files.newInputStream(path);
//2、通过Files获取字符传入缓冲流
BufferedReader reader = Files.newBufferedReader(path);
}
2）通过Files获取字节、字符输出流
>>> 获取字节流
默认情况下，获取字节流
如果path对应文件不存在，则会创建新的文件。
如果path对应的文件存在，则会直接覆盖该文件的内容。
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files获取字节输出流
//如果path对应文件不存在，则会创建新的文件。
//如果path对应的文件存在，则会直接覆盖该文件的内容。
OutputStream outputStream = Files.newOutputStream(path);
}
设置option，获取字节流。
配置读写属性。
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files获取字节输出流
//设置options改变配置
//StandardOpenOption.CREATE：如果文件不存在，则创建新文件。如果文件存在，则不会覆盖。
//tandardOpenOption.APPEND：将数据追加到文件末尾，而不是覆盖文件内容。
//StandardOpenOption.TRUNCATE_EXISTING：如果文件存在，则截断文件（即清空文件内容）。
//StandardOpenOption.WRITE：以写入模式打开文件（默认）。
OutputStream outputStream = Files.newOutputStream(path,StandardOpenOption.CREATE);
}
>>> 获取字符流
默认情况下，获取字符流
如果path对应文件不存在，则会创建新的文件。
如果path对应的文件存在，则会直接覆盖该文件的内容。
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files获取字节输出流
BufferedWriter writer = Files.newBufferedWriter(path);
}
设置option，获取字节流。
配置读写属性。
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files获取字节输出流
//设置options改变配置
//StandardOpenOption.CREATE：如果文件不存在，则创建新文件。如果文件存在，则不会覆盖。
//tandardOpenOption.APPEND：将数据追加到文件末尾，而不是覆盖文件内容。
//StandardOpenOption.TRUNCATE_EXISTING：如果文件存在，则截断文件（即清空文件内容）。
//StandardOpenOption.WRITE：以写入模式打开文件（默认）。
BufferedWriter writer = Files.newBufferedWriter(path,StandardOpenOption.APPEND);
}
3）通过Files直接读写文件
>>>> 通过Files直接读文件
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files获取字节数组
byte[] bytes = Files.readAllBytes(path);
System.out.println(new String(bytes));
//2、通过Files获取文本行
List<String> list = Files.readAllLines(path);
System.out.println(list);
}
>>>> 通过Files直接写文件
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
//1、通过Files直接写字节数组
String str="我是你老爸";
Files.write(path,str.getBytes());
//2、通过Files直接写文本
//覆盖写入
Files.write(path,Arrays.asList("xzx","qweq","爱你"));
}
4.3 判断
1、判断
exists(Path path, LinkOption... options) 测试文件是否存在。
notExists(Path path, LinkOption... options) 测试此路径所在的文件是否不存在。
isDirectory(Path path, LinkOption... options) 测试文件是否是目录。
isSymbolicLink(Path path) 测试文件是否是符号链接，即超链接
isExecutable(Path path) 测试文件是否可执行。
isHidden(Path path) 测试文件是否被隐藏 。
isReadable(Path path) 测试文件是否可读。
isWritable(Path path) 测试文件是否可写。
isSameFile(Path path, Path path2)
测试两个路径是否找到相同的文件。
isRegularFile(Path path, LinkOption... options)
测试文件是否是具有不透明内容的常规文件。说实话，我也不太懂常规文件指的是啥
1）示例
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\数据查询");
System.out.println("判断文件是否存在："+Files.exists(path));
System.out.println("判断文件是否不存在："+Files.notExists(path));
System.out.println("判断文件是否为目录："+Files.isDirectory(path));
System.out.println("判断文件是否为超链接："+Files.isSymbolicLink(path));
System.out.println("判断文件是否可执行："+Files.isExecutable(path));
System.out.println("判断文件是否隐藏："+Files.isHidden(path));
System.out.println("判断文件是否可读："+Files.isReadable(path)); //如果文件不存在，则会报错
System.out.println("判断文件是否可写："+Files.isWritable(path)); //如果文件不存在，则会报错
Path path2 = Paths.get("C:\\Users\\lenovo\\Desktop\\数据查询");
boolean sameFile = Files.isSameFile(path, path2);
System.out.println("判断两个Path路径是否一致："+sameFile);
}
4.4 文件属性方法
1）getFileAttributeView 获取指定的文件属性视图对象进行操作
static <V extends FileAttributeView> V getFileAttributeView(Path path, 类<V> type, LinkOption... options)
获取文件的属性视图。
属性视图提供了一种更灵活的方式来读取和设置文件的元数据（如权限、所有者和其他文件属性）。
指定type，获取对应的属性视图。
1）参数
path: 要访问其属性视图的文件的路径。
type: 属性视图的类型，例如 BasicFileAttributeView, DosFileAttributeView, PosixFileAttributeView, AclFileAttributeView 等。
options: 可选参数，用于指定如何处理符号链接，例如 LinkOption.NOFOLLOW_LINKS。
>>>> options属性详解：属性视图
+++ 属性视图：
选择合适的属性视图，通过属性属性视图来访问文件的属性。
BasicFileAttributeView: 提供基本的文件属性，例如创建时间、最后修改时间、最后访问时间和文件大小。
DosFileAttributeView: 提供 DOS 特定的文件属性，例如只读、隐藏、系统和存档属性。
PosixFileAttributeView: 提供 POSIX 文件系统的属性，例如文件的所有者、组和权限。
AclFileAttributeView: 提供访问控制列表 (ACL) 属性。
UserDefinedFileAttributeView: 提供用户定义的文件属性。
+++ 属性视图的选择
选择合适的属性视图取决于你需要访问或修改的文件属性类型以及文件系统的特性。
以下是常用属性视图的具体使用场景和选择建议：
1. BasicFileAttributeView
使用场景: 当你只需要访问或修改文件的基本属性时，例如创建时间、最后修改时间、最后访问时间和文件大小。
适用性: 适用于所有支持基本文件属性的文件系统。
示例:
BasicFileAttributeView view = Files.getFileAttributeView(path, BasicFileAttributeView.class);
2. DosFileAttributeView
使用场景: 当你需要访问或修改 DOS/Windows 特定的文件属性时，例如只读、隐藏、系统和存档属性。
适用性: 适用于运行在 Windows 文件系统上的应用程序。
示例:
DosFileAttributeView view = Files.getFileAttributeView(path, DosFileAttributeView.class);
3. PosixFileAttributeView
使用场景: 当你需要访问或修改 POSIX（类 Unix 系统）文件系统的属性，例如文件的所有者、组和权限。
适用性: 适用于运行在类 Unix 系统（如 Linux 和 macOS）上的应用程序。
示例:
PosixFileAttributeView view = Files.getFileAttributeView(path, PosixFileAttributeView.class);
4. AclFileAttributeView
使用场景: 当你需要访问或修改文件的访问控制列表（ACL）以实现细粒度的权限控制时。
适用性: 适用于支持 ACL 的文件系统（如 Windows NTFS 文件系统）。
示例:
AclFileAttributeView view = Files.getFileAttributeView(path, AclFileAttributeView.class);
5. UserDefinedFileAttributeView
使用场景: 当你需要存储和检索应用程序特定的元数据或用户定义的文件属性时。
适用性: 适用于支持用户定义文件属性的文件系统。
示例:
UserDefinedFileAttributeView view = Files.getFileAttributeView(path, UserDefinedFileAttributeView.class);
选择指南
基本属性: 如果只需要基本文件属性（如时间戳、大小），使用 BasicFileAttributeView。
Windows 特定属性: 如果需要处理 Windows 特定的文件属性（如只读、隐藏），使用 DosFileAttributeView。
Unix 权限: 如果需要处理类 Unix 系统的文件权限（如所有者、组和权限），使用 PosixFileAttributeView。
访问控制列表: 如果需要更复杂的权限控制（如 ACL），使用 AclFileAttributeView。
用户自定义属性: 如果需要存储自定义的文件属性，使用 UserDefinedFileAttributeView。
每种视图类型都提供特定的功能和适用场景，因此在选择时要根据实际需求和文件系统特性来决定。
>>>> 示例：BasicFileAttributeView属性视图
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
BasicFileAttributeView fileAttributeView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
//获取文件的基础属性
BasicFileAttributes basicFileAttributes = fileAttributeView.readAttributes();
System.out.println("创建时间:"+basicFileAttributes.creationTime());
System.out.println("访问时间:"+basicFileAttributes.lastAccessTime());
System.out.println("修改时间:"+basicFileAttributes.lastModifiedTime());
System.out.println("大小:"+basicFileAttributes.size());
//修改文件基础属性
FileTime nowTime = FileTime.from(Instant.now());
fileAttributeView.setTimes(nowTime,nowTime,nowTime);
}
>>>> 示例：DosFileAttributeView 属性视图
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
DosFileAttributeView dosFileAttributeView = Files.getFileAttributeView(path, DosFileAttributeView.class);
//获取文件的基础属性
DosFileAttributes dosFileAttributes = dosFileAttributeView.readAttributes();
System.out.println("文件创建时间："+dosFileAttributes.creationTime());
System.out.println("文件访问时间："+dosFileAttributes.lastAccessTime());
System.out.println("文件修改时间："+dosFileAttributes.lastModifiedTime());
System.out.println("文件是否隐藏："+dosFileAttributes.isHidden());
System.out.println("文件是否只读："+dosFileAttributes.isReadOnly());
System.out.println("文件是否文件夹："+dosFileAttributes.isDirectory());
//修改文件基础属性
FileTime nowTime = FileTime.from(Instant.now());
dosFileAttributeView.setTimes(nowTime,nowTime,nowTime);
dosFileAttributeView.setHidden(true); //设置文件属性-隐藏
dosFileAttributeView.setSystem(false);//设置文件属性-是否系统文件
}
2）readAttributes 获取指定的文件属性对象进行操作
static <A extends BasicFileAttributes> A readAttributes(Path path, 类<A> type, LinkOption... options)
用于访问文件的属性对象。
通过属性对象获取文件的基本属性。
指定type，获取对应的属性对象。
参数：
path: 要读取属性的文件或目录的路径。
type: 要读取的属性视图的类型，例如 BasicFileAttributes.class, DosFileAttributes.class, PosixFileAttributes.class。
options: 可选参数，用于指定如何处理符号链接，例如 LinkOption.NOFOLLOW_LINKS。
>>>> options属性详解：属性对象
type属性对象
BasicFileAttributes: 提供基本的文件属性，如创建时间、最后修改时间、最后访问时间、文件大小等。
DosFileAttributes: 提供 DOS/Windows 特定的文件属性，如只读、隐藏、系统和存档属性。
PosixFileAttributes: 提供 POSIX 文件系统的属性，如文件的所有者、组和权限。
UserDefinedFileAttributeView: 处理用户定义的文件属性。
>>>> 示例：BasicFileAttributes
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
BasicFileAttributes basicFileAttributes = Files.readAttributes(path, BasicFileAttributes.class);
//获取文件的基本属性
System.out.println("文件创建时间:"+basicFileAttributes.creationTime());
System.out.println("文件访问时间:"+basicFileAttributes.lastAccessTime());
System.out.println("文件修改时间:"+basicFileAttributes.lastModifiedTime());
System.out.println("文件大小:"+basicFileAttributes.size());
System.out.println("文件是否目录:"+basicFileAttributes.isDirectory());
}
>>>> 示例：DosFileAttributes
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
DosFileAttributes dosFileAttributes = Files.readAttributes(path, DosFileAttributes.class);
//获取文件的基本属性
System.out.println("文件创建时间:"+dosFileAttributes.creationTime());
System.out.println("文件访问时间:"+dosFileAttributes.lastAccessTime());
System.out.println("文件修改时间:"+dosFileAttributes.lastModifiedTime());
System.out.println("文件大小:"+dosFileAttributes.size());
System.out.println("文件是否目录:"+dosFileAttributes.isDirectory());
System.out.println("文件是否隐藏:"+dosFileAttributes.isHidden());
System.out.println("文件是否只读:"+dosFileAttributes.isReadOnly());
System.out.println("文件是否系统:"+dosFileAttributes.isSystem());
}
3）readAttributes 获取指定的文件属性对象进行操作【指定属性对象简写】
static Map<String,Object> readAttributes(Path path, String attributes, LinkOption... options)
读取一组文件属性作为批量操作。
用于访问文件的属性对象。
通过属性对象获取文件的基本属性。
参数：
path: 要读取属性的文件或目录的路径。
attributes:
指定要读取的属性名称，可以是单个属性名称或多个属性名称的逗号分隔字符串。
例如 "basic:size,creationTime" 或 "posix:permissions"。
options: 可选参数，用于指定如何处理符号链接，例如 LinkOption.NOFOLLOW_LINKS。
>>>> attributes属性详解：属性对象简写
attributes：
1)常见属性视图和属性名称
basic: 基本属性视图，包括 size, creationTime, lastModifiedTime, lastAccessTime, isDirectory, isRegularFile, isSymbolicLink, isOther。
dos: DOS 文件属性视图，包括 readonly, hidden, system, archive。
posix: POSIX 文件属性视图，包括 permissions, owner, group。
user: 用户定义的文件属性视图，用于获取自定义属性。
2)使用指南
基本文件属性: 使用 "basic" 视图和相应属性名称。多个以逗号分隔。
Files.readAttributes(path,"basic:size,creationTime")
Windows 特定属性: 使用 "dos" 视图和相应属性名称。
Files.readAttributes(path,"dos:readonly,size")
类 Unix 系统属性: 使用 "posix" 视图和相应属性名称。
Files.readAttributes(path,"posix:permissions")
用户自定义属性: 使用 "user" 视图和自定义属性名称。
Files.readAttributes(path,"user:xxx,xx2")
>>>> 示例
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
Map<String, Object> map = Files.readAttributes(path, "basic:size,creationTime");
System.out.println(map);
Map<String, Object> dosMap = Files.readAttributes(path, "dos:size,creationTime");
System.out.println(dosMap);
}
4）getAttribute、setAttribute
static Object getAttribute(Path path, String attribute, LinkOption... options)
读取文件属性的值。这个 String attributes 参数的语法固定是以 view-name:comma-separated-attributes 的形式；view-name指定视图名如basic,posix,acl等，不写默认为basic；有写默认要加":"；可以用"basic：*"或"*"读取所有，又或者用"basic：size，lastModifiedTime"读取大小和修改时间。具体还有那些属性可以看具体指定的类，比如basic视图就看BasicFileAttributes这个接口都有哪些方法，可以读取哪些文件属性。同理，下面的 String attributes 一样是这个理
static Path setAttribute(Path path, String attribute, Object value, LinkOption... options)
设置文件属性的值。
>>>> attribute属性详解：属性对象简写
attribute：
1)常见属性视图和属性名称
basic: 基本属性视图，包括 size, creationTime, lastModifiedTime, lastAccessTime, isDirectory, isRegularFile, isSymbolicLink, isOther。
dos: DOS 文件属性视图，包括 readonly, hidden, system, archive。
posix: POSIX 文件属性视图，包括 permissions, owner, group。
user: 用户定义的文件属性视图，用于获取自定义属性。
2)使用指南
基本文件属性: 使用 "basic" 视图和相应属性名称。
Files.getAttribute(path,"basic:size")
Windows 特定属性: 使用 "dos" 视图和相应属性名称。
Files.getAttribute(path,"dos:readonly")
类 Unix 系统属性: 使用 "posix" 视图和相应属性名称。
Files.getAttribute(path,"posix:permissions")
用户自定义属性: 使用 "user" 视图和自定义属性名称。
Files.getAttribute(path,"user:xxx")
4）通过Files直接获取或设置
/* 下面这些也是获取属性的方法，不过还没研究到是怎么用的 */
static FileTime getLastModifiedTime(Path path, LinkOption... options)
返回文件的上次修改时间。
static UserPrincipal getOwner(Path path, LinkOption... options)
返回文件的所有者。
static Set<PosixFilePermission> getPosixFilePermissions(Path path, LinkOption... options)
返回文件的POSIX文件权限。
static long size(Path path)
返回文件的大小（以字节为单位）。
static Path setLastModifiedTime(Path path, FileTime time)
更新文件上次修改的时间属性。
static Path setOwner(Path path, UserPrincipal owner)
更新文件所有者。
static Path setPosixFilePermissions(Path path, Set<PosixFilePermission> perms)
设置文件的POSIX权限。
>>>> 示例
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\lenovo\\Desktop\\新建文件夹\\NEW FOLDER\\NEW FOLDER2\\x.txt");
FileTime lastModifiedTime = Files.getLastModifiedTime(path);
System.out.println(lastModifiedTime);
UserPrincipal owner = Files.getOwner(path);
System.out.println(owner);
FileStore fileStore = Files.getFileStore(path);
System.out.println(fileStore);
}
4.5 遍历文件列表方法
newDirectoryStream只是遍历当前Path的子目录列表，或者写一个方法里面递归调用实现遍历到底；
walk则是可以通过maxDepth参数来决定遍历的深度，后面的FileVisitOption参数可有可无；
list类似于newDirectoryStream，区别是walk和newDirectoryStream是递归的，list是非递归的
static DirectoryStream<Path> newDirectoryStream(Path dir)
打开一个目录，返回一个DirectoryStream以遍历目录中的所有条目。最好用 try-with-resources 构造，可以自动关闭资源。返回的 DirectoryStream<Path> 其实可以直接使用 Iterator或者for循环 遍历每一个 dir 下面的文件或目录
static DirectoryStream<Path> newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)
上面方法的重载，通过实现参数二(有一个 boolean accept(Path p) 方法来判断文件是否符合需要)来达到过滤的目的。如accept方法中写"return (Files.size(p) > 8192L);"来匹配大于8k的文件
static DirectoryStream<Path> newDirectoryStream(Path dir, String glob)
上面方法的重载，可以通过参数二作为过滤匹配出对应的文件。如 newDirectoryStream(dir, "*.java") 用于遍历目录里所有java后缀的文件
static Stream<Path> walk(Path start, FileVisitOption... options)
深度优先遍历。返回一个 Stream ，它通过 Path根据给定的起始文件的文件树懒惰地填充 Path 。
static Stream<Path> walk(Path start, int maxDepth, FileVisitOption... options)
深度优先遍历。返回一个 Stream ，它是通过走根据给定的起始文件的文件树懒惰地填充 Path 。
static Stream<Path> list(Path dir)
返回一个懒惰的填充 Stream ，其元素是 Stream中的条目。返回的 Stream 里封装了一个 DirectoryStream 用于遍历。
