IO流

一.流概念



二.IO框架



Stream–动态从一头将数据传输到另一头的过程（多数流不会自动刷新，需要在流关闭时，或使用刷新方法才能传输到另一头）

字节流 – 不定长的流，与之相关的文件叫二进制文件或数据文件

字符流 – 定长的流，每个单元都是字符，字符流相关的文件叫字符文件，或文本文件

参考系 – 所有IO中读或者写，输入或者输出的参考系都是内存

二进制：InputStream/OutputStream

文本：Reader/Writer

举例：

程序->文本文件：Writer

文本文件->程序:Reader

程序->网络(二进制)：OutputStream

二进制文件->程序:InputStream

 

 

一、     File类：（文件类）

1.   构造函数：

File（File父文件,String子文件）

File（String父文件,String子文件）

File（String抽象 路径）

File（URi）-----java.net.URI类

2.   抽象路径，绝对路径，相对路径：

绝对路径：c:\apache\htdocs\cgi-bin\test.cgi-----给输入输出用的

相对路径：type cgi-bin\test.cgi----给输入输出用的

抽象路径：给java自己用的

3.   个性方法：

mikdir：创建一层目录

mikdirs：创建多层目录

createNewFile：创建文件

list（）：--String[ ]

listFiles（）：---File[ ]

4.   递归读取：

listFiles（）：---File[ ]-----用于遍历

isFile（）-----用于判断

二、      RandomAccessFilejava提供对内容的访问，可读也可写

  RandomAccessFile支持随机访问文件，可以访问文件任何位置

(1)java文件模型

在硬盘上以byte类型存储，数据的集合

(2)打开文件

有两种模式“rw（读写）”，“r”是只读

产生对象的方法 RandomAccessFile raf=new RandomAccessFile（file,"rw"）;

(3)方法：

写：raf.write（int n）;

读：int b=raf.read();

指针：raf.seek（0）;

(4)读写完后要关闭 raf.close();

三、      字节流（不定长的流，与之相关的文件叫二进制文件或数据文件）

Ø  定义：不定长的流，与之相关的文件叫二进制文件或数据文件

Ø  适用范围：用于向字节流读取8位二进制的字节，字节流类主要用于读写图像声音等二进制数据。

抽象类读写：（putStream，OutputStream）----->继承于java.lang.Object
类

1）（抽象类读取数据），（抽象类写出数据方式）

2）EOF=End 读到-1就结束了

3）输入流基本方法

intb=in.read(); 读取一个字节无符号填充到int低八位

in.read(byte[]buf);

in.read(byte[]buf,int start,int size）

close（）;

4）输出流基本方法

out.write();

out.write(inta);写出一个字节到流，int的低8位

out.write(byte[]b);全部字节写到流

out.write(byte[]buf,int off,int size);

flush();

close();

 

 

 

 

 

 

 

《一滴一滴转移》

具体类读写（FileInputStream，FileOutputStream）--->继承于java.io.OutputStream
类和FileInputStream类

//如果该文件不存在，则直接创建，如果存在，删除后创建

FileOutputStreamout=new FileOutputStream("demo/out.dat");

//如果该文件不存在，则直接创建，如果存在，在后面直接追加

FileOutputStreamout=new FileOutputStream("demo/out.dat，true");

方法：write(),flush（），close（）；

 

 

《一瓢一瓢转移》

具体类承于java.io.FilterInputStream
，间接继承于java.io.InputStream
类

DataOutputStream使用了装饰模式，可以写任何类型的数据

流只能顺序读，顺序写；如果顺序错了抛出异常

用哪种方式写就用哪种方式读

DataOutputStream(newFileOutputStream）

方法：read（）， readInt（），readDouble（），readChar（）

 

 

《一瓢一瓢放入桶中，再将桶转移》

直接继承于java.io.FilterInputStream
，间接继承于java.io.InputStream
类

定义：

BufferedInputStream&BufferedOutputStream----带缓冲字节流

这两个流类位IO提供了带缓冲区的操作，一般打开文件进行写入

或读取操作时，都会加上缓冲，这种流模式提高了IO的性能

从应用程序中把输入放入文件，相当于将一缸水倒入另一缸中

 

构造方法及主要方法：

BufferedInputStream(newFileInputStream，int size） 

BufferedOutputStream(newFileOutputStream，int size）

BufferedOutputStream----->write方法相当于一瓢一瓢放入桶中，再将桶中倒入缸

bos.flush()刷新缓冲区，不刷新写不进去read（）,close()

 

四、      字符流（定长的流，每个单元都是字符，字符流相关的文件叫字符文件，或文本文件参考系 – 所有IO中读或者写，输入或者输出的参考系都是内存）

1.        认识文本和文本文件

java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）

文件是byte byte byte的数据序列

文本文件是文本（char）序列按照某种编码方案（utf-8，utf-16be，gbk）序列化为byte的存储

2.        转换字符流（InputStreamReader，OutputStreamWriter）

字符的处理，一次处理一个字符；字符的底层仍然是基本的字节序列；字符流的基本实现

继承于java.io.Reader 类

InputStreamReader(in码格式）  完成byte流解析为char流，按照编码解析

方法：read(buffer,0,buffer.length)

OutputStreamWriter(out格式）  提供char流到byte流，按照编码处理

intc=isr.read(buffer,0,buffer.length);

方法：write(buffer,0,c)

文件拷贝过程，先用in读read()文件-------》再用write写文件

3.        字符流实例（FileReader，FileWriter）

------->继承于java.io.InputStreamReader 类------->间接继承于java.io.Reader类

FileReader（String Filepath）---完成byte流解析为char流，按照编码解析

继承于java.io.OutputStreamReader 类

FileWriter（String Filepath）---提供char流到byte流，按照编码处理

 

 

4.        带缓冲字符流实例（BufferedReader，BufferedWriter）

------->继承于java.io.Reader，java.io.writer

带缓冲字符流

BufferedReader（new InputStreamReader（new FileIn putStream（String）））

------->继承于java.io.Writer 类

BufferedWriter(new OutputStreamReader（new FileOutputStream（String）））

一行一行读，方法：readline（）;

bw.newLine();换行操作

5.        打印输出

------->继承于java.io.Writer 类

PrintWriter（）

五、     序列化与反序列化

1）对象序列化，就是将Object转化成byte序列，反之叫反序列化

java.io.ObjectOutputStream

2)序列化流（ObjectOutputStream），是过滤流-----writeObject

java.io.ObjectInputStream 

 反序列化流（ObjectInputStream），readObject

3)序列化接口（Serializable）

对象必须实现序列化接口，才能进行序列化，否则出现异常

这个接口没有任何方法

4）对象要实现Serializable接口才能实现序列化

有效元素序列化，无效元素不序列化

read的时候要进行强转

5）被transient修饰后不会进行序列化，默认为0.

如果要显示出来，必须定义私有方法

privatevoid writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{

                s.defaultWriteObject();

                s.writeDouble(price);

       }

privatevoid readObject(java.io.ObjectInputStream s)

              throws java.io.IOException, ClassNotFoundException {

                s.defaultReadObject();

                s.ReadDouble(price);

 

6）序列化优化

 

7）序列化中子父类构造函数问题（只要没实现序列化接口，均可以调用）

如果只有父类实现了序列化接口-----那么父，子，孙均不能调用构造函数

如果只有子类实现了序列化接口-----那么只有父类可以调用构造函数，子类和孙类均不能调用构造函数