1.什么是数据流?

数据流是指所有的数据通信通道。有两类流，InputStream and OutputStream，Java中每一种流的基本功能依赖于它们。InputStream用于read，OutputStream用于write，读 和写都是相对于内存说的，读就是从其他地方把数据拿进内存，写就是把数据从内存推出去。这两个都是抽象类，不能直接使用。

2.InputStream的方法有：

read()从流中读入数据有3种方式：

◆int read() 一次读一个字节

◆int read(byte[]) 读多个字节到数组中

◆int read(byte[],int off,int len) 指定从数组的哪里开始，读多长

◆skip() 跳过流中若干字节

◆available() 返回流中可用字节数，但基于网络时无效，返回0

◆markSupported() 判断是否支持标记与复位操作

◆mark() 在流中标记一个位置，要与markSupported()连用

◆reset() 返回标记过的位置

◆close() 关闭流

3.OutputStream的方法：

◆write(int)写一个字节到流中

◆write(byte[])将数组中的内容写到流中

◆write(byte[],int off,int len)将数组中从off指定的位置开始len长度的数据写到流中

◆close()关闭流

◆flush()将缓冲区中的数据强制输出

4.File类

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

构造器：

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

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

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

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

常用方法：

boolean createNewFile();

boolean exists();

例子：

//建立 test.txt 文件对象，判断是否存在，不存在就创建

import java.io.*;

public class CreateNewFile

{

public static void main(String args[])

{

File f=new File("test.txt");

try

{

if(!f.exists())

{

f.createNewFile();

}

else

{

System.out.println("exists");

}

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

boolean mkdir()/mkdirs()

boolean renameTo(File destination)

例子：

//看一下这 mkdir()/mkdirs() 的区别和 renameTo 的用法

import java.io.*;

public class CreateDir

{

public static void main(String args[])

{

File f=new File("test.txt");

File f1=new File("Dir");

File f2=new File("Top/Bottom");

File f3=new File("newTest.txt");

try

{

f.renameTo(f3);

f1.mkdir();

f2.mkdirs();

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

String getPath()/getAbsolutePath()

String getParent()/getName()

例子：

//硬盘上并没有parent 目录和 test.txt 文件，但我们仍然可以操作，因为我们创建了他们的对象，是对对象进行操作

import java.io.*;

public class Test

{

public static void main(String args[])

{

File f=new File("parent/test.txt");

File f1=new File("newTest.txt");

try

{

System.out.println(f.getParent());

System.out.println(f.getName());

System.out.println(f1.getPath());

System.out.println(f1.getAbsolutePath());

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

String list[] //显示目录下所有文件

long lastModified() //返回 1970.1.1 到最后修改时间的秒数

boolean isDirectory()

例子：

//列出目录下的所有文件和目录，最后修改时间，是目录的后面标出

import java.io.*;

import java.util.*;

public class Dir

{

public static void main(String args[])

{

File f=new File("Dir");

String[] listAll=null;

File temp=null;

try

{

listAll=f.list();

for(int i=0;i

{

temp=new File(listAll);

System.out.print(listAll+"\t");

if(temp.isDirectory())

{

System.out.print("\t

}

else

{

System.out.print(temp.length()+"\t");

}

System.out.println(new Date(temp.lastModified()));

}

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

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

}

}

}

}

}

10.随机存取文件RandomAccessFile

可同时完成读写操作

支持随机文件操作的方法：

readXXX()/writeXXX()

seek()将指针调到所需位置

getFilePointer()返回指针当前位置

length()返回文件长度

例子：

把若干个32位的整数写到一个名为“temp.txt”的文件中，然后利用seek方法，以相反的顺序再读取这些数据。

import java.io.*;

public class RandomFile

{

public static void main(String args[])

{

RandomAccessFile raf=null;

int data[]={12,31,56,23,27,1,43,65,4,99};

try

{

raf=new RandomAccessFile("temp.txt","rw");

for(int i=0;i

raf.writeInt(data);

for(int i=data.length-1;i>=0;i--)

{

raf.seek(i*4);

System.out.println(raf.readInt());

}

}

catch(Exception e)

{

e.getMessage();

}

finally

{

if(raf!=null)

{

try

{

raf.close();

}

catch(Exception e)

{

e.getMessage();

}

}

}

}

}

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 (常用)

c. 随机存取文件RandomAccessFile