输入输出应用编程（输入输出流）Files工具方法，Path相关方法

码&

已于 2022-08-02 21:23:11 修改

阅读量384

点赞数 1

分类专栏：面向对象输入输出流文章标签： jvm java 开发语言

于 2022-08-01 21:26:05 首次发布

本文链接：https://blog.csdn.net/qq_51222096/article/details/126108985

版权

面向对象同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

输入输出流

9 篇文章 0 订阅

订阅专栏

Input/Output ：指跨越出了 JVM 的边界，与外界数据的源头或者目标数据源进行数据交换

Java程序会从各种地方输入数据，比如文件，磁盘，网络，其它程序中
Java会采用不同的方式输出执行结果，比如屏幕、文件、磁盘、网络等

输入 / 输出是针对 JVM 而言

输入输出种的流模型

在 Java 程序中，对于数据的输入输出操作以流 Stream 方式进行， JavaSE 提供各种各样的类用于使用相同的方法获取不同类型的数据，程序中通过标准的方法输入或者输出数据流是处理输入/ 输出的一个洁净的方法，它不需要代码理解键盘和网络的不同。 Java 中流的实现是基于java.io包定义的类层次结构的

流概念

java.io 包通过数据流、序列化和文件系统为用户提供一种完成 I/O 操作的输入 / 输出流

数据流是指所有的数据通信通道

流是字节或字符数据的数据源或目的，用以隐藏数据传输细节，可以从流读取数据或将数据写到流

Java 程序不能直接操纵 I/O 设备，而是在程序和设备之间加入了一个中间介质，这就是流。 IO 输入输出通

常指数据在内部存储器和外部存储器或其它周边设备之间的输入输出

流是数据传输的抽象表达，与具体设备无关。程序一旦建立了流，就可以不用理会起点或终点是何种设

备建立流实际上就是建立数据传输通道，将起点和终点连接起来

Java 程序通过流来完成输入 / 输出，它是生产或消费信息的抽象

流通过 Java 的输入 / 输出系统与物理设备链接。尽管与它们链接的物理设备不尽相同，但是所有流的

行为具有同样的方式

相同的输入 / 输出类和方法适用于所有类型的外部设备。这意味着一个输入流能够抽象多种不同类

型的输入，从磁盘文件，从键盘或从网络套接字获取输入，一个输出流可以输出到控制台，磁盘文件

或相连的网络。流是处理输入 / 输出的一个洁净的方法，它不需要代码理解键盘和网络的不同。

流的分类

从 Java 不同版本上来说，流可以分为 BIO 、 NIO 和 AIO 三大类。 Java 中的 BIO 、 NIO 和 AIO 理解为是 Java

语言对操作系统的各种 IO 模型的封装。程序员在使用这些 API 的时候，不需要关心操作系统层面的知

识，也不需要根据不同操作系统编写不同的代码。只需要使用 Java 的 API 就可以了。

BIO 即同步阻塞 I/O 模式，数据的读取写入必须阻塞在一个线程内等待其完成。

NIO 即同步非阻塞，一个线程不断的轮询每个输入输出的状态改变，如果有状态发生了改变，则进

行下一步的操作。

AIO 即异步非阻塞 I/O 模型，无需一个线程去轮询所有 IO 操作的状态改变，在相应的状态改变后，系

统会通知对应的线程来处理。

同步 / 异步关注的是消息通信机制。

同步Synchronous是指发起一个调用后，调用方必须等待此调用返回结果后才能继续执行。
异步Asynchronous是指发起一个调用后，调用方可继续执行后续操作，被调用者执行结束主动给调用方返回结果。

阻塞 / 非阻塞关注的是程序在等待调用结果时的状态，区别在于第一步发起 IO 请求后是否会被阻塞。

阻塞是指调用结果返回前，当前线程会被挂起，调用线程只有在得到结果之后才返回。
非阻塞是指在调用结果返回前，不影响当前线程执行其他操作，也就是不会阻塞当前线程。

BIO 是一种同步阻塞的通信模式，是一个比较传统的通信方式，模式简单、使用方便，但并发处理

能力低，通信耗时，依赖网速。

NIO(Non-Bock) IO 是一种同步非阻塞的通信模式，针对网络传输效能优化的新功能。

AIO(Asynchronous IO) 是一种异步非阻塞的通信模式。

同步阻塞的工作模式是先来到厨房，开始烧水，并在水壶旁等待直到水开了为止
同步非阻塞的工作模式是指来到厨房，开始烧水，这次不在水壶旁等着，回到客厅看电视，每隔几分钟去检查水是否烧开了
异步非阻塞的工作模式是指来到厨房，开始烧水，回到客厅看电视，直到听到水烧开后水壶的提示音。

同步 vs 异步：指的是被调用方以何种方式返回调用结果？（我们如何知道水壶中的水烧开了，是主动发现还是水壶被动提醒）

阻塞 vs 非阻塞：指的是调用方在调用后的状态是否是阻塞？（我们把水壶烧水开关打开后，我们是否在水壶旁等待水烧开）

适用场景

BIO适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解
NIO适用于连接数目比较多且连接比较短的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持
AIO方式适用于连接数目多且连接比较长的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。
按流向分为输入流和输出流，可以从输入流读取数据但不能写，要从输入流读取数据，则必须有一个与这个流相关的字符源
按传输单位分为字节流和字符流
Java具备平台无关性，这里的字节是指8位，字符是16位
字节流从InputStream/OutputStream派生出来，以字节为基本处理单位，一般用于操作二进制数据，字节次序是有意义的
字符流从Reader/Writer派生出来的，以16位的Unicode码表示字符为基本处理单位，一般用于操作字符数据
使用桥接流可以实现两个流之间的转换

按功能还可以分为节点流和过滤流

节点流：负责数据源和程序之间建立连接，结点流对特定的地方读写
过滤流：用于给节点增加功能，过滤流使用结点流进行输入/输出并添加附加功能

过滤流的构造方式是以其他流位参数构造（这样的设计模式称为装饰模式）。 Java 的 IO 流使用装饰器模式，将IO 流分成底层节点流和上层处理流。其中节点流用于和底层的物理存储节点直接关联。过滤流是连接在已存在的流之上，通过对数据的处理为程序提供更为强大的读写功能。

注意：I/O流是一类很宝贵的资源，使用完后必须调用close()方法关闭流并释放资源。在关闭流时只用关闭最外层的流

字符流就是字节流读取文字字节数据后，不直接操作而是先查指定的编码表以获取对应的文字。简单的说：字符流 = 字节流 + 编码表

字符流的两个顶层父类：Reader和Writer
字节流的两个顶层父类：InputStream和OutputStream
输入输出靠reader和writer, inputstream和outputstream四个类和子类支持
读入的内容有对象，字符，图像和声音等

Java 输入输入靠 reader 、 writer 、 InputStream 、 OutputStream 四个类和子类支持。 JDK 的 I/O 包中使用Decorator模式，并运用此模式，实现一个新的输出流类

扩展类的功能

扩展一个类功能的最简单方式就是继承

继承

public interface IShape{
    void draw();
}

需要追加功能的类实现

public class Circle implements IShape{
    @Override 
    public void draw() { 
        System.out.println("我画一个圆"); 
    }
}

通过继承添加子类用于追加功能

public class CircleExtends extends Circle { 
    @Override 
    public void draw() { 
        System.out.println("我使用红色"); // 追加的功能 
        super.draw(); //调用父类中被覆盖的方法 
        System.out.println("我收齐图片")； // 追加的功能 
    } 
}

测试程序

IShape s1=new CircleExtends(); 
s1.draw();

最大的问题是耦合

装饰模式

装饰器模式 Decorator Pattern 允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活
主要解决：一般的为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀
优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能
缺点：多层装饰比较复杂
使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承。

要求：

1 、被装饰方 ( 多个 ) 有个抽象角色 --- 接口、抽象类

2 、装饰方实现接口（继承抽象类），并将装饰方定义为属性

Decorator 模式又名包装器 Wrapper ，它的主要用途在于给一个对象动态的添加一些额外的职责。与生成子类相比，它更具有灵活性

装饰器模式中的四种角色：被装饰对象、装饰对象、装饰器 Decorator 、公共接口或抽象类

被装饰方的抽象角色，未来可能会有多种实现

public interface IShape{ 
    void draw(); 
}

具体的被装饰方实现，这里可能会有多个实现类，而且具体实现方式不相同

public class Circle implements IShape{ 
    public void draw(){ 
    System.out.println("画一个圆") 
    } 
}

装饰抽象角色：未来装饰方可以当作 IShape 类直接进行调用

public abstract class DecorateShape implements IShape{ 
    private IShape shape;//装饰方，就是需要动态追加功能的对象 
    public DecorateShape(IShape shape){ 
        this.shape=shape; 
} 
//当调用装饰方的draw方法时，实际上最终工作的是被装饰方，装饰方只是在被装饰方执行动作时添 加额外的处理 
    public void draw(){ 
        shape.draw(); 
    } 
}

具体的装饰角色

public class RedDecorateShape extends DecorateShape{ 
    public RedDecorateShape(IShape shape){ 
        super(shape); }
    //父类中并没有添加新功能，在子类中重新覆盖定义追加具体的功能 
    public void draw(){ 
        super.draw(); 
        useRed();//就是具体动态追加的功能 
        }
        private void useRed(){ 
        System.out.println("使用红色的边线"); 
    } 
}

测试：

IShape circle=new Circle();//被装饰方对象，就是需要给它动态添加功能 
IShape decorate=new RedDecorateShape(circle);
//装饰方对象，它给circle对象添加功能 
decorate.draw(); //实际应用中可能会简化写成 
IShape test=new RedDecorateShape(new Circle());

在IO流定义中使用装饰模式

Java.io 包中大量的使用了设计模式中的装饰模式 decorator 和适配器模式 adapter ，使 IO 库具有很强的对称性和可扩展性，对称性表现在I/O 的对称和 byte/char 流的对称上。

抽象角色

public abstract class InputStream implements Closeable{ 
    public abstract int read() throws IOException; 
}

这里节点流就是这个抽象角色的具体实现，例如 FileInputStream

装饰 ( 抽象 ) 角色用于通过继承定义过滤流

public class FilterInputStream extends InputStream{ 
    protected volatile InputStream in; 
    protected FilterInputStream(InputStream in){ 
        this.in=in; 
    }
    public int read()throws IOException{ 
        return in.read(); 
    } 
}

装饰的具体角色真正添加功能，例如 BufferedInputStream 就是给节点流上添加缓存

public class BufferedInputStream extends FilterInputStream{ 
    public BufferedInputStream(InputStream in){ 
        this(in, DEFAULT_BUFFER_SIZE); 
    }
    public synchronized int read() throws IOException{ 
        if(pos>=count) ...

File类

类File提供了一种与机器无关的方式来描述一个文件对象的属性
对于目录，Java把它简单的处理为一种特殊的文件，即文件名的列表
java.io.File用于封装和平台无关的文件夹和文件夹对象，例如获取一个文件的字节数。这个写法是针对windows平台的，如果使用mac或者linux平台，则需要使用
通过类File中提供的方法，可以得到文件或者目录的描述信息，包括名称、所在路径、可读性等，还可以生成新的文件、目录、改变文件名、删除文件、列出一个目录中所有的文件或者与某个模式匹配的文件等

常见的构造方法

File(String pathName)以path为路径创建File对象，如果pathname是相对路劲，则默认的当前路径在系统属性user.dir中存储
File(String parent,String child) 这里文件对象的路径为相对于parent路径的child路径

需要记忆的方法

// File ff=new File("e:\\ 综合面试 .txt"); 绝对路径的写法，其中的路径分割符可以使用

\\ 或者 /

File ff = new File ( "e:/ 综合面试 .txt" );

System . out . println ( ff . getAbsolutePath ()); // 用于获取文件对象的绝对路径 e:\ 综合面

试 .txt

// 判断正确的前提是必须存在

System . out . println ( ff . isDirectory ()); //false 用于判断当前文件对象是否为文件夹

System . out . println ( ff . isFile ()); //true 用于判断当前文件对象是否为文件

System . out . println ( ff . length ()); // 获取指定文件对象的字节数 , 单位为字节

System . out . println ( ff . exists ()); // 是否存在对应的文件对象 , 返回 true 则表示存在

ff . delete () // 删除文件或者文件夹，注意 Java 并不能保证删除一定成功

ff . mkdirs () // 创建多级文件夹 , 而使用 mkdir 只能创建一层文件夹

// 实际编程中很少使用的方法

listFiles (): File [] // 获取当前文件夹的所有子文件信息，子文件为 File 对象

静态属性

Separator 存储当前系统的路径分隔符

注意： \ 在字符串中为转义字符，如果需要使用 \ 则必须写成 \\ 。一般推荐使用 /

File f1 = new File ( "c:\\windows\\setupact.log" );

File f2 = new File ( "c:/windows/setupact.log" ); // 这里的 / 等价于上面的 \\

File f3 = new

File ( "c:" + File . separator + "windows" + File . separator + "setupact.log" );

System . out . println ( File . pathSeparator ); // 路径分隔符；如果写多个路径使用 ; 分割

System . out . println ( File . separator ); // 目录的分隔符 \

访问文件名的方法

getName():String获取文件名称
getPath():String获取路径，如果构建File时使用的是相对路径，则这里返回的就是相对路径；如果创建时参数为绝对路径，则返回绝对路径
getAbsolutePath():String获取绝对路径
getParent():String获取当前文件对象的上级File对象，如果构建文件对象时使用的是相对路径，则这里返回为null

文件检测相关方法

canWrite():boolean 是否可写

canRead():boolean 是否可读

首先exists()存在性判断，存在时再进行是否文件或者文件夹的判断

isFile():boolean 是否是文件，因为File对象可以封装文件和文件夹

isDirectory():boolean是否为文件夹

isAbsolute():boolean是否为绝对路径

lastModified():long 文件的最后修改时间

常见操作

createNewFile():boolean创建一个新文件

这个方法中有个受检型异常需要进行处理，处理方法： try/catch 结构或者在方法上 throws 抛出异常

如果文件不存在则返回 true ，表示创建成功；如果文件已经存在则返回 false ，表示创建失败

File ff = new File("abc.txt"); 
if (!ff.exists()) 
    ff.createNewFile(); 
System.out.println(ff.getAbsolutePath());

static createTempFile(String prefix, string suffix):File 这个临时文件名称会有随机内容

临时文件的默认存放位置为操作系统默认的临时文件位置

c:\Users\Administrator\AppData\Local\Temp\

//C:\Users\Administrator\AppData\Local\Temp\abc7595623142286422875.bak

//C:\Users\Administrator\AppData\Local\Temp\abc6103677978020067241.bak

File ff = File . createTempFile ( "abc" , ".bak" ); // 其中 abc 是文件的前缀内容， .bak 是文件的后

缀，其中包含一段随机内容

System . out . println ( ff . getAbsolutePath ());

exists():boolean文件或者文件夹是否存在
length():long获取文件大小，单位为字节，如果是文件夹则返回值没有指定

File ff = new File("c:\\test/aa.txt");

if ( ff . exists () && ff . isFile ())

System . out . println ( ff . length ());

renameTo(File):boolean修改名称，可以修改文件名和文件夹名称
delete():boolean 删除文件。也可以删除文件夹，要求文件夹为空，不能有文件和子文件夹

注意：因为具体的文件或者文件夹的删除操作是由操作系统负责实现的，所以 Java 不能保证一定能

够删除成功 !

deleteOnExit():void 退出系统时自动删除

目录操作方法

mkdir():boolean 只能创建一层文件夹，如果创建 d:/a1/a2/a3 时，当父文件夹 d:/a1/a2 不存在时则

创建失败

mkdirs():boolean 自动创建多级文件夹

list():String[]获取当前文件夹的所有子文件信息
listFiles():File[]获取当前文件夹的所有子文件信息，子文件为File对象

File f=new File("d:/abc"); 
System.out.println(f.exists()); 
File[] fs=f.listFiles(); //即使abc文件夹下为空时则返回的是一个长度为0的数组，而不是null；只有无权访问时才有返回null 的可能 
for(File temp:fs) 
    System.out.println(temp);

static listRoots():File[] 列出系统的所有的根路径

文件过滤器FilenameFilter

带参数的 listFiles 方法支持对于子文件进行过滤，只获取需要满足条件的文件对象

FilenameFilter 接口中包含一个 accept(File dir,String name) 方法，该方法用于对指定 File 的所有子目录

或者文件进行迭代，如果方法返回 true 则 list 方法会获取该目录或者文件

匿名内部类的写法 : 推荐写法

语法糖Lambda表达式

1、函数式接口

@FunctionInterface 
public interface FilenameFilter{

2 、具体的表达式写法

File[] fs=f.listFiles((dir,name)->{ 
    return name!=null && name.endsWith(".ini"); 
});

简化写法

String[] nameList=file.list((dir,name)->name.endWith(“.java”) || new File(name).isDirectory())；

Path和Paths以及Files

Path 接口代表一个平台无关的平台路径

Files 提供工具方法操作文件

Paths 提供创建 Path 的静态工厂方法

Path相关方法

Path path=Paths.get("c:","ddd","eee"); //对应c:\dddd\eee路径 
Path path=Paths.get("."); //获取当前路径对象 
path.toAbsolutePath()//获取path对应的绝对路径 
path.toAbsolutePath().getRoot()//获取path对应的根路径