Java基础 IO流

1.IO简介

1.1继承结构

in/out相对于程序而言的输入(读取)和输出(写出)的过程。
在Java中，根据处理的数据单位不同，分为字节流和字符流

java.io包：
File
字节流：针对二进制文件
InputStream
–FileInputStream
–BufferedInputStream
–ObjectInputStream
OutputStream
–FileOutputStream
–BufferedOutputStream
–ObjectOutputStream
字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8
Writer
–BufferedWriter
–OutputStreamWriter
Reader
–BufferedReader
–InputStreamReader
–PrintWriter/PrintStream

1.2流的概念

数据的读写抽象成数据，在管道中流动
流只能单方向流动
输入流用来读取in
输出流用来写出out
数据只能从头到尾顺序的读写一次

1.3File文件流

1.3.1概述

封装一个磁盘路径字符串，对这个路径可以执行一次操作。
可以用来封装文件路径、文件夹路径、不存在的路径。

1.3.2创建对象

File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

1.3.3常用方法

文件、文件夹属性

lenth():文件的字节量
exists():是否存在，存在返回true
isFile():是否为文件，是文件返回true
isDirectory():是否为文件夹，是文件夹返回true
getName():获取文件/文件夹名
getparent():获取父级文件夹的路径
getAbsolutePath():获取文件的完整路径

创建、删除

createNewFile():新建文件，文件夹不存在会异常，文件已经存在返回false
mkdirs()：新建多层不存在的文件夹\a\b\c
mkdir()：新建单层不存在的文件夹\a
delete()：删除文件，删除空文件夹

文件夹列表

list()：返回String[]，包含文件名
listFiles()：返回File[]，包含文件对象

1.4字节流读取

字节流是由字节组成的,字符流是由字符组成的. Java里字符由两个字节组成.字节流是最基本的，所有的InputStream和OutputStream的子类都是，主要用在处理二进制数据。
流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。

1.4.1 InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类。
常用方法：

abstract int read()
从输入流中读取数据的下一个字节。
int read(byte[] b)
从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b, int off, int len)
将输入流中最多 len 个数据字节读入 byte 数组。
void close()
关闭此输入流并释放与该流关联的所有系统资源。

1.4.2 FileInputStream子类

直接插在文件上，直接读取文件数据
创建对象

FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String pathname)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

1.4.3 BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8M大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
创建对象:

BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

1.5 字符流读取

常用于处理纯文本数据。

1.5.1 Reader抽象类

用于读取字符流的抽象类。
常用方法:

int read()
读取单个字符。
int read(char[] cbuf)
将字符读入数组。
abstract int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。
int read(CharBuffer target)
试图将字符读入指定的字符缓冲区。
abstract void close()
关闭该流并释放与之关联的所有资源。

1.5.2 InputStreamReader子类

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
创建对象:

InputStreamReader(InputStream in, String charsetName)
创建使用指定字符集的 InputStreamReader。
InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader。

1.5.3 FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
创建对象：

FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。
FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。

1.5.4 BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
创建对象：

BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。

1.6 练习 ：文件的读取

//这个类用来测试  字符流读取
		//总结：
		//1、执行效率上：BufferedReader >  FileReader 
		//2、原因是：底层维护了一个char[] ，可以按照数组的长度一次性的读取一大批数据。默认的容量是8192字节量，也就是8K。
		public class Test2_In2 {
			public static void main(String[] args) {
		//		method();//FileReader读取
				method2();//BufferedReader读取
			}
			public static void method2() {
				try {
					//1、创建对象
					Reader in = new BufferedReader(new FileReader("D:\\iotest\\1.txt"));
					//2、开始读取
					int b = 0 ;
					while(  ( b = in.read() ) != -1) {
						System.out.println(b);
					}
					//3、释放资源
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			//FileReader读取
			public static void method() {
				try {
					//1、创建对象
					Reader in = new FileReader("D:\\iotest\\1.txt") ;
					Reader in2 = new FileReader(new File("D:\\iotest\\1.txt")) ;
					//2、开始读取
					int b = 0 ; //定义变量，记录读取到的数据
					while( ( b = in.read() )  != -1 ) {
						System.out.println(b);
					}
					//3、释放资源
					in.close();
					
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			
		}

2.字节流写出

2.1 OutputStream抽象类

是字节流输出流的父类，而且是抽象类。所以不能创建对象，
我们还是只能学习他的共性方法。。
常用方法：

void close()
关闭此输出流并释放与此流有关的所有系统资源。
void flush()
刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)
将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void write(int b)
将指定的字节写入此输出流。

2.2 FileOutputStream子类

文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
创建对象：

FileOutputStream(File file)
FileOutputStream(String name)
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)

2.3 BufferedOutputStream子类

该类实现缓冲的输出流
创建对象

BufferedOutputStream(OutputStream out)

2.4 代码测试

//这个类用来测试  字节流写出
		//总结：
		//1、执行效率上：BufferedOutputStream >  FileOutputStream 
		//2、原因是：底层维护了一个byte[] ，可以按照数组的长度一次性的向磁盘中写出一大批数据。默认的容量是8192字节量，也就是8K。
		public class Test3_Out {
			public static void main(String[] args) {
		//		method();//普通的写出流FileOutputStream
				method2();//高效的写出流BufferedOutputStream
			}
			public static void method2() {
				try {
					//1、创建对象
		//			OutputStream out = new BufferedOutputStream(
		//									new FileOutputStream("D:\\iotest\\1.txt"));//覆盖
					OutputStream out = new BufferedOutputStream(
										new FileOutputStream("D:\\iotest\\1.txt",true));//追加
					
					//2、开始写出
					out.write(48);
					out.write(48);
					out.write(48);
					
					//3、释放资源
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			public static void method() {
				try {
					//1、创建对象－－默认是数据覆盖模式，也可以改成追加模式，需要传入第二参数true
					OutputStream out = new FileOutputStream("D:\\iotest\\1.txt");//默认覆盖
		//			OutputStream out = new FileOutputStream("D:\\iotest\\1.txt",true);//数据追加
		//			OutputStream out2 = new FileOutputStream(new File("D:\\iotest\\1.txt")) ;
					
					//2、开始写出
					out.write(49);
					out.write(50);
					out.write(51);
					
					//3、释放资源
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}		
			}
		}

3. 字符流写出

3.1 Writer抽象类

是字符流写出流的父类，而且是一个抽象类。不能创建对象，只能学习他的共性方法。
常用方法

void write(char[] cbuf)
写入字符数组。
abstract void write(char[] cbuf, int off, int len)
写入字符数组的某一部分。
void write(int c)
写入单个字符。
void write(String str)
写入字符串。
void write(String str, int off, int len)
写入字符串的某一部分。
abstract void close()
关闭此流，但要先刷新它。

3.2 OutputStreamWrite子类

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
创建对象

OutputStreamWriter(OutputStream out, String charsetName)
创建使用指定字符集的 OutputStreamWriter。
OutputStreamWriter(OutputStream out)
创建使用默认字符编码的 OutputStreamWriter。

3.3 FileWriter子类

用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
创建对象：

FileWriter(File file)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)
FileWriter(File file, boolean append)

3.4BufferedWriter子类

将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了
创建对象

BufferedWriter(Writer out)

3.5代码测试

//这个类用来测试  字符流写出
		//总结：
		//1、执行效率上：BufferedWriter >  FileWriter 
		//2、原因是：底层维护了一个char[] ，可以按照数组的长度一次性的向磁盘中写出一大批数据。默认的容量是8192字节量，也就是8K。
		public class Test4_Out2 {
			public static void main(String[] args) {
		//		method(); //FileWriter写出
				method2(); //BufferedWriter写出
			}
			public static void method2() {
				try {
					//1、创建对象
					Writer out = new BufferedWriter(new FileWriter("D:\\iotest\\1.txt"));
					//2、开始写出
					out.write("hello");
					//3、释放资源
		//			out.flush();//用来把缓冲区的数据刷到磁盘中做展示
					out.close();//1、把数据刷出去  2、关闭资源
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			public static void method() {
				try {
					//1、创建对象
		//			Writer out = new FileWriter("D:\\iotest\\1.txt") ;//覆盖
					Writer out = new FileWriter("D:\\iotest\\1.txt",true) ;//追加
		//			Writer out2 = new FileWriter(new File("D:\\iotest\\1.txt")) ;
					
					//2、开始写出
					out.write(48);
					out.write(48);
					
					//3、释放资源
					out.close();
					
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
		}

3.6 文件复制(读一行写一行)

//这个类用来测试文件复制  --高效的字节流
	public class Test5 {
		public static void main(String[] args) {
			try {
	//		1、读取源文件的数据
		InputStream in = new BufferedInputStream(new FileInputStream("D:\\iotest\\1.txt"));
	//		2、写出数据到目标文件中
		OutputStream out = new BufferedOutputStream(new FileOutputStream("D:\\iotest\\2.txt"));
				
				//3、读取数据同时写出，边读边写！！
				int b = 0 ;//定义变量，记录读取到的数据
				while(( b = in.read() ) !=  -1 ) {
					out.write(b);//把读取到的数据，写出
				}
				
				//4、释放资源
				in.close();
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		}
	}