输入输出种的流模型、扩展类的功能、File类、文件过滤器FilenameFilter、Path和Paths以及Files、字节流

以下为今天的总结内容：输入输出种的流模型、扩展类的功能、File类、文件过滤器FilenameFilter、Path和Paths以及Files、字节流。

输入输出应用编程

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

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

输入/输出是针对JVM 而言

输入输出种的流模型

在Java程序中，对于数据的输入输出操作以流Stream方式进行，JavaSE提供各种各样的类用于使用相同的方法获取不同类型的数据，程序中通过标准的方法输入或者输出数据

流是处理输入/输出的一个洁净的方法，它不需要代码理解键盘和网络的不同。Java中流的实现是基于java.io包定义的类层次结构的

流概念

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

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

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

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

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

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

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

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

相同的输入/输出类和方法适用于所有类型的外部设备。这意味着一个输入流能够抽象多种不同类型的输入， 从磁盘文件，从键盘或从网络套接字获取输入，一个输出流可以输出到控制台，磁盘文件或相连的网络。流是处理输入/输出的一个洁净的方法，它不需要代码理解键盘和网络的不同。

流的分类

从Java不同版本上来说，流可以分为BIO、NIO和AIO三大类。Java 中的 BIO、NIO和 AIO 理解为是 Java 语言对操作系统的各种 IO 模型的封装。程序员在使用这些 API 的时候，不需要关心操作系统层面的知识，也不需要根据不同操作系统编写不同的代码。只需要使用Java的API就可以了。

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

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

• AIO即异步非阻塞I/O模型，无需一个线程去轮询所有IO操作的状态改变，在相应的状态改变后，系统会通知对应的线程来处理。

• 按流向分为输入流和输出流，可以从输入流读取数据但不能写，要从输入流读取数据，则必须有一个与这个流相关的字符源

• 按传输单位分为字节流和字符流

  • Java具备平台无关性，这里的字节是指8位，字符是16位
  • 字节流从InputStream/OutputStream派生出来，以字节为基本处理单位，一般用于操作二进制数据，字节次序是有意义的
  • 字符流从Reader/Writer派生出来的，以16位的Unicode码表示字符为基本处理单位，一般用于操作字符数据
  • 使用桥接流可以实现两个流之间的转换

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

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

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

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

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

扩展类的功能

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

继承

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、装饰方实现接口（继承抽象类），并将装饰方定义为属性
被装饰方的抽象角色，未来可能会有多种实现

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();
}
}

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

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

File类

java.io.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是否可读
• isFile():boolean 是否是文件，因为File对象可以封装文件和文件夹
• isDirectory():boolean是否为文件夹
• isAbsolute():boolean是否为绝对路径
• lastModied():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 prex, string sux):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方法会获取该目录或者文件

@FunctionalInterface
public interface FilenameFilter {
//参数dir是文件所在的目录，name是文件名称
boolean accept(File dir, String name); //当返回值为true时表示要，否则不要
}

public class Test3 {
public static void main(String[] args) {
File ff=new File("c:/windows");
File[] children=ff.listFiles(new MyFileNameFilter());
for(File temp:children)
System.out.println(temp.getAbsolutePath());
}
static class MyFileNameFilter implements FilenameFilter{
public boolean accept(File dir, String name) {
return name.endsWith(".exe");
}
}
}

匿名内部类的写法:

public class Test3 {
public static void main(String[] args) {
File ff=new File("c:/windows");
File[] children=ff.listFiles(new FilenameFilter() {
public boolean accept(File dir, String name) {
return name!=null && name.endsWith(".exe");
}
});
for(File temp:children)
System.out.println(temp.getAbsolutePath());
}
}

语法糖Lambda表达式

函数式接口

@FunctionInterface
public interface FilenameFilter{

具体的表达式写法

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对应的根路径

Files工具方法

复制文件Files.copy(Paths.get(“T1.java”), new FileOutputStream(“a.txt”))

一次性读取文件的所有行 List lines=Files.readAllLines()

字节流

在顶层有两个抽象类InputSream和OutputStream。

InputSream和OutputStream中定义了read()和write()方法，它们被派生流类重载。字节流是字节序列，它与外部设备中的字节存在着一一对应的关系，不存在字符的转换，被读写字节的个数与外部设备中的字节个数是相同的

基本输入输出方法

System类是Java语言中一个功能强大、非常有用的类，它提供了标准输入/输出及运行时的系统信息

• System类不能创建对象，也就是说，System类的所有属性和方法都是静态的，引用时要以System作为前缀
• System.in与System.out是System类的两个静态属性，分别对应了系统的标准输入/输出流

System类管理标准输入输出流和错误流

• System.out：把输出送到缺省的显示(通常是显示器)，是PrintStream的对象
• System.in：从标准输入获取输入(通常是键盘)，是InputStream的对象
• System.err：把错误信息送到缺省的显示，是PrintStream的对象

同时使用System.out和System.err输出信息不能保证显示顺序就是执行顺序，为了避免这种情况在测试代码执行中经常使用System.err输出

练习
用户在键盘依次输入若干个数字，每输入一个数字都需要按回车键确认，最后在键盘输入一个非数字字符串结束整个输入操作过程。程序将计算出这些数的和以及平均值。

System.out.println("提示信息：");
try {
//从键盘上读取一个字节的数据并返回读取的int类型内容0-255，如果输入中文则会出现乱码，因为一个中文是2个字节构成
//如果用户不输入任何内容，则当前程序会在这里阻塞等待，直到用户输入为止---BIO
int kk=System.in.read();//这个方法上有个IOException异常，属于受检型异常，必须进行处理，处理方法有throws或者try/catch
System.out.println((char)kk);//将读取内容转换为char类型进行显示
} catch (Exception e) {
e.printStackTrace();
}

使用字节数组读取一组内容

System.out.println("提示信息：");
byte[] buffer=new byte[8192];//注意一般设置缓存默认值都是8192--8K
try {
//从键盘读取内容放入到buffer字节数组中，并返回读取的字节数.如果用户不输入数据则一直阻塞等待
int len=System.in.read(buffer);
//如果输入的是中文信息，则会多两个字节长[和操作系统平台相关],不管中文信息中字符个数,一个中文为2个字节
if(len>0){
System.out.println("读取的字节数为："+len);
String str=new String(buffer);//将数组内容转换为String类型数据
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
}

• FileInputStream、FileOutputStream 顺序读取文件
• PipedInputStream、PipedOutputStream 管道
• ByteArrayInputStream、ByteArrayOutputStream 内存读写
• FilterInputStream、FilterOutputStream 过滤流（有多线程同步）
• DataInputStream、DataOutputStream 对数据类型读写，有多线程同步
• BueredInputStream、BueredOutputStream 缓冲类型读写