Io字节流、字符流

Io字节流

i:input 输入（读取）
o:output输出 （写入）
流：数据（字符、字节） 1个字符 = 2个字节 1个字节 = 8个二进制位

&nbsp	输入流	输出流
字节流	InputStream	OutputStream
字符流	Reader	Wirter

java.io.OutputStream:此抽象类是所有字节输出流的父类

字节输出流写多个字节
public void write(byte[] b); 将b.length字节从指定的字节数组写入此输入流
一次写入多个字节：
如果写的第一个字节是正数（0-127），那么显示的时候查询ASCII表。
如果写的第一个字节是负数，那第一个字节会和第二个字节，组成一个中文显示，查询默认表码（GBK）。

---

public void write(byte[] b,int off,int len):把字节数组的一部分写入到文件中
int off:数组开始的索引
int Len： 写几个数组

byte[] bytes={65,66,67,68,69};//ABCDE
//byte[] bytes={-65,-66,-67,68,69};//烤怏E
fos.write(bytes);
fos.close();//释放资源
-------------------------------------
byte[] bytes2 = "你好".getBytes();
System.out.println(Arrays.toString(bytes2));//{-28,-67,-96,-27,-91,-67};
fos.write(bytes2);
fos.close();//释放资源

字节输出流的续写
追加写/续写两种构造方法：
·FileOutputStream(String name,boollean append)创建一个向指定nama的文件中写入数据的输出文件流。
·FileOutputStream(File file,boollean append)创建一个向指定File对象表示的文件写入数据的输出文件流。
参数：String name, File file :写入数据的目的地
Boolean append :追加写开关
turn：不会覆盖写，
false: 创建一个新文件，覆盖原文件
写换行：windows:\r\n;
linux:/n

psvm{
	FileOutputStream fos= new FileOutputStream(c:\\user,true);
	fos.write("你好".getBytes());
	fos.write("\r\n".getBytes());
	fos.close();
	

字节输入流
java.io.InputStreamr:字符输入流，是字节输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
共性的成员方法：
int read() 读取单个字符并返回
int read(char[] cbuf) 一次读取多个字符，将字符读入数组
void close() 关闭该流并释放与之关联的所有资源

java.io.FileInputStream extends InputStream
java.io.FileInputStream 文件字节输入流
作用：把硬盘中的文件数据，读取到内存中使用

构造方法: FileInputStream(String name)
FileInputStream(File file )
参数：读取文件的数据源
String name 文件的路径
File file : 文件
读取数据的原理（硬盘–>内存）
java程序–JVM–OS–OS读取数据的方法–读取文件
字节输入流的使用步骤（重点）
1.创建FileInputStream对象，构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的read方法，读取文件
3.释放资源

public static void main(String[] args) throws IOException{
	//1.创建FileInputStream对象，构造方法中绑定要读取的数据源
	FileInputStream fis = new FileInputStream("bin\\.a.txt");
	//  2.使用FileInputStream对象中的read方法，读取文件
	//int read()读取文件中的一个字节并返回，读取到文件的末尾返回
	int len = fis.read();
	System.out.println(len);
	/*
		当读取文件是一个重复的过程，可以使用while循环优化

		boolen表达式：（len=fis.read()）!=-1
		1.fis.read() 读取一个字节
		2.len = fis.read() 把读取的字节赋值给变量len
		3.(len=fis.read()!=-1)判断变量len是否不等于-1
	*/
	int len = 0;
	while ((len = fis.read())!=-1){
		System.out.print((char)len);
		}
	fis.close();
	}
	

字节输入流一次读区多个字节
方法： int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

参数：byte[] 起到缓冲作用存储每次读取到的多个字节
int 每次读到的有效字节个数

//while循环
	byte[] bytes = new byte[1024];//存储读取到的多个字节
	int len = 0; //记录每次读取的有效字节个数
	while ((len=fis.read(bytes))!=-1){
		System.out.println(new String (bytes,0,len));
	}
	

IO字符流

java.io.Reader:字符输入流，是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
共性的成员方法：
int read() 读取单个字符并返回
int read(char[] cbuf) 一次读取多个字符，将字符读入数组
void close() 关闭该流并释放与之关联的所有资源

java.io.FileReader extends InputStreamReader extends Reader
FileReader : 文件字符输入流
作用：把硬盘中的文件中的数据以字符的方式读取到内存中

构造方法：
FileReader(String fileName)
FileReader(File file)
参数：读取文件的数据源
String fileName 文件的路径
File file 一个文件
FileReader构造方法的作用：
1.创建FileReader对象
2.会把FileReader对象指向要读取的文件

字节输入流的使用步骤（重点）
1.创建FileReader对象，构造方法中绑定要读取的数据源
2.使用FileIReader对象中的read方法，读取文件
3.释放资源
字符输出流
java.io.Write : 字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类
共性的成员方法：
void write (int c) 写入单个字符
void write(char[] cbuf) 写入字符数组
abstract void writer(char[] cbuf,int off, int len) 写入数组的一部分
void write (String str) 写入字符串
void write (String str,int off, int len) 写入字符串 的一部分
void flush() 刷新该流的缓冲
void close() 关闭此流，但要先刷新它。

java.io.FileWrite extends InputStreamWrite extends Write
FileWrite : 文件字符输出流
作用：把内存中的字符数据写入到文件中
构造方法：
FileWriter(String fileName)
FileWriterr(File file)
参数：写入数据的目的地
String fileName 文件的路径
File file 一个文件
FileReader构造方法的作用：
1.创建FileWriter对象
2.会把FileWriter对象指向创建好的文件
3.会根据构造方法中传递的文件、文件的路径，创建文件

字节输入流的使用步骤（重点）
1.创建FileWriterr对象，构造方法中绑定写入数据的目的地
2.使用FileIWriter中的方法writer，把数据写入到内存缓冲区中（字符转换为字节的过程）
3.使用FileWriter中的flush,把内存中的数据，刷新到文件中
4.释放资源（会把内存缓冲区中的数据刷新到文件中）

flush方法和close方法的区别：
flush ： 刷新缓冲区，流对象可以继续使用
close： 先刷新缓冲区，然后通知系统释放资源。 流对象不可以在被使用。

public static void main(String[] args) throws IOException{
	//1.创建FileWriterr对象，构造方法中绑定写入数据的目的地
	FileWrite fw = new FileWrite("bin\\.a.txt");
	//2.使用FileIWriter中的方法writer，把数据写入到内存缓冲区中（字符转换为字节的过程）
	fw.write(97);
	//3.使用FileWriter中的flush,把内存中的数据，刷新到文件中
	fw.flush();
	//4.释放资源（会把内存缓冲区中的数据刷新到文件中）
	fis.close();
	}

字符输出流的续写
追加写/续写两种构造方法：
·FileWriter(String name,boollean append)
·FileWriter((File file,boollean append)
参数：String name, File file :写入数据的目的地
Boolean append :追加写开关
turn：不会覆盖写，
false: 创建一个新文件，覆盖原文件
写换行：windows:\r\n;
linux:/n

public static void main(String[] args) throws IOException{
		FileWrite fw = new FileWrite("bin\\.a.txt");
		for(int i=0;i<10;i++){
			fw.writer("HelloWorld"+i+""\r\n);
			}
	fos.close();
	}