数据流

1.什么是数据流 ?

数据流是指所有的数据通信通道

有两类流，InputStream and OutputStream，Java中每一种流的基本功能依赖于它们

InputStream 用于read,OutputStream 用于write, 读和写都是相对与内存说的，读就是从其他地方把数据拿进内存，写就是把数据从内存推出去这两个都是抽象类，不能直接使用

4.File 类

File 可以表示文件也可以表示目录，File 类控制所有硬盘操作

构造器：

File(File parent,String child) 用父类和文件名构造

File(String pathname) 用绝对路径构造

File(String parent,String child) 用父目录和文件名构造

File(URI uri) 用远程文件构造

常用方法：

boolean createNewFile();

boolean exists();

5.文件流的建立

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

}}}

6.缓冲区流

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

}}}

7.原始型数据流

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){

}}}}

8.对象流

串行化：对象通过写出描述自己状态的数值来记述自己的过程叫串行化

对象流：能够输入输出对象的流

将串行化的对象通过对象流写入文件或传送到其他地方，对象流是在普通流上加了传输对象的功能，所以构造对象流时要先构造普通文件流

注意：只有实现了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();

}}}}

 

9.字符流 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();

}}}}

11.小结

a. 字节流：

InputStream

|-- FileInputStream (基本文件流）

|-- BufferedInputStream

|-- DataInputStream

|-- ObjectInputStream

OutputStream 同上图

BufferedInputStream，DataInputStream，ObjectInputStream 只是在FileInputStream 上增添了相应的功能，构造时先构造FileInputStream

b. 字符流：

Reader

|-- InputStreamReader (byte->char 桥梁）

|-- BufferedReader (常用）

Writer

|-- OutputStreamWriter (char->byte 桥梁）

|-- BufferedWriter

|-- PrintWriter （常用）

转自：http://blog.csdn.net/yakihappy/article/details/3979822