数据流，对象流，字节流，字符流

1.什么是数据流 ?
数据流是指所有的数据通信通道
有两类流，InputStream and OutputStream，Java中每一种流的基本功能依赖于它们
InputStream 用于read,OutputStream 用于write, 读和写都是相对与内存说的，读就是从其他地方把数据拿进内存，写就是把数据从内存推出去这两个都是抽象类，不能直接使用
2.File 类
File 可以表示文件也可以表示目录，File 类控制所有硬盘操作
构造器：
File(File parent,String child) 用父类和文件名构造
File(String pathname) 用绝对路径构造
File(String parent,String child) 用父目录和文件名构造
File(URI uri) 用远程文件构造
常用方法：
boolean createNewFile();
boolean exists();
3.文件流的建立

File f=new File("temp.txt");
FileInputStream in=new FileInputStream(f);
FileOutputStream out=new FileOutputStream(f);

例子：文件拷贝

import java.io.*;
public class Copy{
public static void main(String args[]){
FileInputStream fis=null;
FileOutputStream fos=null;
try{
fis=new FileInputStream("c2.gif");
fos=new FileOutputStream("c2_copy.gif");
int c;
while((c=fis.read()) != -1)
fos.write(c);
}catch(Exception e){
e.printStackTrace();
}finally{
if(fis != null) try{ fis.close(); }catch(Exception e){ e.printStackTrace(); }
if(fos!= null) try{ fos.close(); }catch(Exception e){ e.printStackTrace(); }
}}}

4.缓冲区流
BufferedInputStream
BufferedOutputStream
他们是在普通文件流上加了缓冲的功能，所以构造他们时要先构造普通流
例子：文件拷贝的缓冲改进

import java.io.*;
public class Copy{
public static void main(String args[]){
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
byte buf[]=new byte[100];
try{
bis=new BufferedInputStream(new FileInputStream("persia.mp3"));
bos=new BufferedOutputStream(new FileOutputStream("persia_copy.mp3"));
int len=0;
while( true ){
len=bis.read(buf);
if(len<=0) break;
bos.write(buf,0,len);
}
bos.flush();//缓冲区只有满时才会将数据输出到输出流，用flush()将未满的缓冲区中数据强制输出
}catch(Exception e){
e.printStackTrace();
}finally{
if(bis != null) try{ bis.close(); }catch(Exception e){ e.printStackTrace(); }
if(bos!= null) try{ bos.close(); }catch(Exception e){ e.printStackTrace(); }
}}}

5.原始型数据流
DataInputStream
DataOutputStream
他们是在普通流上加了读写原始型数据的功能，所以构造他们时要先构造普通流方法：
readBoolean()/writeBoolean()
readByte()/writeByte()
readChar()/writeByte()
......
例子：//这个流比较简单，要注意的就是读时的顺序要和写时的一样

import java.io.*;
public class DataOut{
public static void main(String args[]){
DataOutputStream dos=null;
try{
dos=new DataOutputStream(new FileOutputStream("dataout.txt"));
dos.writeInt(1);
dos.writeBoolean(true);
dos.writeLong(100L);
dos.writeChar('a');
}catch(Exception e){
e.printStackTrace();
}finally{
if(dos!=null)
try{
dos.close();
}catch(Exception e){
}}}}
 
import java.io.*;
public class DataIn{
public static void main(String args[]){
DataInputStream dis=null;
try{
dis=new DataInputStream(new FileInputStream("dataout.txt"));
System.out.println(dis.readInt());
System.out.println(dis.readBoolean());
System.out.println(dis.readLong());
System.out.println(dis.readChar());
}catch(Exception e){
e.printStackTrace();
}finally{
if(dis!=null)
try{
dis.close();
}catch(Exception e){
}}}}

6.对象流
串行化：对象通过写出描述自己状态的数值来记述自己的过程叫串行化
对象流：能够输入输出对象的流
将串行化的对象通过对象流写入文件或传送到其他地方，对象流是在普通流上加了传输对象的功能，所以构造对象流时要先构造普通文件流
注意：只有实现了Serializable接口的类才能被串行化

例子：

import java.io.*;
class Student implements Serializable{
private String name;
private int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void greeting(){
System.out.println("hello ,my name is "+name);
}
public String toString(){
return "Student["+name+","+age+"]";
}}
public class ObjectOutTest{
public static void main(String args[]){
ObjectOutputStream oos=null;
try{
oos=new ObjectOutputStream(new FileOutputStream("student.txt"));
Student s1=new Student("Jerry",24);
Student s2=new Student("Andy",33);
oos.writeObject(s1);
oos.writeObject(s2);
}catch(Exception e){
e.printStackTrace();
}finally{
if(oos!=null)
try{
oos.close();
}catch(Exception e){
e.printStackTrace();
}}}}
 
import java.io.*;
public class ObjectInTest{
public static void main(String args[]){
ObjectInputStream ois=null;
Student s=null;
try{
ois=new ObjectInputStream(new FileInputStream("student.txt"));
System.out.println("--------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
System.out.println("--------------------");
s=(Student)ois.readObject();
System.out.println(s);
s.greeting();
}catch(Exception e){
e.printStackTrace();
}finally{
if(ois!=null)
try{
ois.close();
}catch(Exception e){
e.printStackTrace();
}}}}

附：如何遍历对象
ObjectInputStream无论是读对象，还是记取int等java的基本数据类型，在判结束时，绝对既不是-1，也不是什么null。
若文件中有若于个int的数，你用DataInputStream中的readint()去读，何时判读到结尾？ 绝对既不是-1，也不是什么null
同样道理：若文件中有若于个Object对象，你用ObjectInputStream中的readObject()去读，何时判读到结尾？
绝对既不是-1，也不是什么null
方法之一：（常用的方法）将若干个对象（数量不定）都装入一个容器中（如：ArrayList之类），然后将容器这一个对象写入就行了。读取时，只要读取一个对象（即容器对象）就行了。
方法之二：（若不想用容器），则由于数量不定，正是用EOFException来判断结束。代码结构如下：(无论是readInt()读int，还是readObject()读对象)
try{
while(true){
Object o=ois.radObject();
处理已读出的对象o; }
}catch(EOFxception e){ 已从流中读完。 }
finallly{ 流的关闭。 }


7.字符流 InputStreamReader/OutputStreamWriter
上面的几种流的单位是 byte，所以叫做字节流，写入文件的都是二进制字节，我们无法直接看，下面要学习的是字节流。Java采用 Unicode 字符集，每个字符和汉字都采用2个字节进行编码，ASCII 码是 Unicode 编码的子集。
InputStreamReader 是 字节流 到 字符桥的桥梁 （ byte->char 读取字节然后用特定字符集编码成字符)
OutputStreamWriter是 字符流 到 字节流的桥梁 （ char->byte )
他们是在字节流的基础上加了桥梁作用，所以构造他们时要先构造普通文件流
我们常用的是:
BufferedReader 方法：readLine()
PrintWriter 方法：println()
例子：

import java.io.*;
public class PrintWriterTest{
public static void main(String args[]){
PrintWriter pw=null;
try{
pw=new PrintWriter(new OutputStreamWriter(new FileOutputStream("bufferedwriter.txt")));
pw.println("hello world");
}catch(Exception e){
e.printStackTrace();
}finally{
if(pw!=null)
try{
pw.close();
}catch(Exception e){
e.printStackTrace();
}}}}
 
import java.io.*;
public class BufferedReaderTest{
public static void main(String args[]){
BufferedReader br=null;
try{
br=new BufferedReader(new InputStreamReader(new FileInputStream("bufferedwriter.txt")));
System.out.println(br.readLine());
}catch(Exception e){
e.printStackTrace();
}finally{
if(br!=null)
try{
br.close();
}catch(Exception e){
e.printStackTrace();
}}}}

8.小结
a. 字节流：
InputStream
|-- FileInputStream (基本文件流）
|-- BufferedInputStream
|-- DataInputStream
|-- ObjectInputStream
OutputStream 同上图
BufferedInputStream，DataInputStream，ObjectInputStream 只是在FileInputStream 上增添了相应的功能，构造时先构造FileInputStream

b. 字符流：
Reader
|-- InputStreamReader (byte->char 桥梁）
|-- BufferedReader (常用）
Writer
|-- OutputStreamWriter (char->byte 桥梁）
|-- BufferedWriter
|-- PrintWriter （常用）