Java的输入输出流

今天回顾和学习了Java中输入和输出流的建立和应用，学会了在Java程序中通过标准的方法输入或者输出数据，通过练习和理解明白了如何在Java中使用其方法完成所需要求，完成任务

输入输出应用编程

1、输入输出种的流模型

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

1.1、流概念
java.io包通过数据流、序列化和文件系统为用户提供一种完成I/O操作的输入/输出流
数据流是指所有的数据通信通道
流是字节或字符数据的数据源或目的，用以隐藏数据传输细节，可以从流读取数据或将数据写到流
Java程序不能直接操纵I/O设备，而是在程序和设备之间加入了一个中间介质，这就是流
流是数据传输的抽象表达，与具体设备无关。程序一旦建立了流，就可以不用理会起点或终点是何种设备
建立流实际上就是建立数据传输通道，将起点和终点连接起来Java程序通过流来完成输入/输出，它是生产或消费信息的抽象
流通过Java的输入/输出系统与物理设备链接。尽管与它们链接的物理设备不尽相同，但是所有流的行为具有同样的方式
相同的输入/输出类和方法适用于所有类型的外部设备。这意味着一个输入流能够抽象多种不同类型的输入， 从磁盘文件，从键盘或从网络套接字获取输入，一个输出流可以输出到控制台，磁盘文件或相连的网络。流是处理输入/输出的一个洁净的方法，它不需要代码理解键盘和网络的不同。
1.2、流的分类
从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流分成底层节点流和上层处理流。其中节点流用于和底层的物理存储节点直接关联。过滤流是连接在已存在的流之上，通过对数据的处理为程序提供更为强大的读写功能。

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

2、扩展类的功能

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

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

2.2、装饰模式
装饰器模式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();
	}
	// 父类中并没有添加新功能，在子类中重新覆盖定义追加具体的功能
	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());

2.3、在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) 

3、File类

java.io.File用于封装和平台无关的文件夹和文件夹对象
例如获取一个文件的字节数
这个写法是针对windows平台的，如果使用mac或者linux平台，则需要使用
3.1、常见的构造方法
File(String pathName)以path为路径创建File对象，如果pathname是相对路劲，则默认的当前路径在系统属性user.dir中存储
File(String parent,String child) 这里文件对象的路径为相对于parent路径的child路径
3.2、需要记忆的方法

//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对象

3.3、静态属性
Separator存储当前系统的路径分隔符
注意： \ 在字符串中为转义字符，如果需要使用 \ 则必须写成 \ 。一般推荐使用/
3.4、访问文件名的方法

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

3.5文件检测相关方 法

• canWrite():boolean 是否可写
• canRead():boolean是否可读
• isFile():boolean 是否是文件，因为File对象可以封装文件和文件夹
• isDirectory():boolean是否为文件夹
• isAbsolute():boolean是否为绝对路径
• lastModied():long文件的最后修改时间

3.6、常见操作
createNewFile():boolean创建一个新文件
这个方法中有个受检型异常，需要进行处理,处理方法：try/catch结构或者在方法上throws抛出异常
如果文件不存在则返回true，表示创建成功；如果文件1、要求显示整个windows文件夹中的所有文件和

4、编程练习

如果是文件则显示 文件名称 大小
如果是文件夹则显示 绝对路径 是一个文件夹已经存在则返回false，表示创建失败

public class Test3 {
    
    
	public static void main(String[] args) {
    
    
		File ff = new File("c:/windows");
		showFile(ff);
	}
	public static void showFile(File target) {
    
    
		if (target != null) {
    
    
			if (target.isFile()) {
    
    
				System.out.println("\t" + target.getName() + "\t" + target.length());
			} else if (target.isDirectory()) {
    
    
				System.out.println(target.getAbsolutePath() + "是文件夹!");
				File[] fs = target.listFiles();
				if (fs != null && fs.length > 0) {
    
    
					for (File tmp : fs)
						showFile(tmp);
				}
			}
		}
	}
}

2、编写程序，在命令行中以树状结构显示特定的文件夹及其子文件夹，如果子文件是文件则需要显示文件大小，最后统计整个目录的大小

public class Test1 {
    
    
	static long fileNum = 0;
	static long fileLen = 0;
	public static void main(String[] args) {
    
    
		String ss = "C:\\software\\eclipse";
		File ff = new File(ss);
		if (ff != null && ff.exists()) {
    
    
			System.out.println(ff.getParent().getAbsolutePath());
			showFile(ff, 0);
		}
		System.out.println(ff.getAbsolutePath() + "的文件数目为：" + fileNum + ",总大小为：" + fileLen);
	}
	public static void showFile(File ff, int level) {
    
    
		if (ff != null) {
    
    
			for (int i = 0; i < level; i++)
				System.out.print(" ");
			System.out.print("|-");
			if (ff.isFile()) {
    
    
				fileNum++;
				fileLen += ff.length();
				System.out.println(ff.getName() + ":" + ff.length());
			} else if (ff.isDirectory()) {
    
    
				System.out.println(ff.getName());
				File[] fs = ff.listFiles();
				for (File temp : fs)
					showFile(temp, level + 1);
			}
		}
	}
}

3、定义一个方法，能够删除任意文件夹，文件夹路径由键盘录入

public class Test2 {
    
    
	public static void main(String[] args) {
    
    
		File ff = new File("c:\\abc");
		delFile(ff);
	}
	private static void delFile(File ff) {
    
    
		if (ff != null) {
    
    
			if (ff.isFile())
				ff.delete();
			else if (ff.isDirectory()) {
    
    
				File[] fs = ff.listFiles();
				for (File temp : fs)
					delFile(temp);
				ff.delete();
			}
		}
	}
}

4.1、文件过滤器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());
	}
}