java中常见的I/O流总结

Java流操作有关的类或接口：

Java流类图结构：

FilInputStream文件输入流（字节输入流）
FilterInputStream过滤输入流（封装其他输入流）
BufferInputStream缓冲输入流
ObjectInputStream 对象输入流
ByteArrayInputStream字节数组输入流
PrintStream字节打印流
InputStreamReader转换流（字节到字符的转换）
OutStreamWrite转换流（字符到字节的转换）
StringWriter 字符输出流

IO流的分类

根据处理数据类型的不同分为：字符流和字节流
根据数据流向不同分为：输入流和输出流

字符流和字节流

字节流：以字节为单位读取的流
字符流：以字符为单位读取的流
字节流和字符流的区别：
读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

1.1 FileOutputStream类

(1)基本概念
java.io.FileOutputStream类主要用于将字节流数据写入到输出流中。
(2)常用的方法
FileOutputStream(String name) - 按照参数指定的路径构造对象。
FileOutputStream(String name, boolean append) - 按照追加的方式构造对象与指定的路径关联。
void write(int b) - 写入单个字节。
void write(byte[] b, int off, int len) - 写入数组中的一部分字节数据。 > void write(byte[] b) - 写入整个数组的字节数据。
void flush() - 刷新输出流并强制写入缓冲数据。
void close() - 关闭输出流并释放资源。

1.2 FileInputStream类
(1)基本概念
java.io.FileInputStream类用于读取诸如图像之类的原始字节流。
(2)常用的方法

FileInputStream(String name) - 根据参数指定的文件进行关联并创建对象。
int read() - 用于读取一个字节数据，返回-1表示读到文件末尾，否则返回数据。
int read(byte[] b) - 用于读满整个字节数组。
- 若读到文件尾就返回-1，否则返回实际读取的字节数。
int read(byte[] b, int off, int len) - 用于读满字节数组的一部分空间。
void close() - 关闭流并释放资源。
1.3 DataOutputStream类
(1)基本概念

java.io.DataOutputStream类用于将java中的基本数据类型写入输出流中。
(2)常用的方法
DataOutputStream(OutputStream out) - 根据参数指定的引用构造对象。
void writeInt(int v) - 用于将参数指定的整数写入输出流中。
void flush() - 刷新输出流 void close() - 关闭输出流

1.4 DataInputStream类
(1)基本概念
java.io.DataInputStream类用于读取java中的基本数据类型。
(2)常用的方法

DataInputStream(InputStream in) - 根据参数指定的引用构造对象。
- 引用是一个抽象类，实参需要传递子类的对象。
void close() - 关闭输入流。

1.5 BufferedReader类
(1)基本概念
java.io.BufferedReader类用于读取单个字符、字符数组、一行字符的数据。
(2)常用的方法

BufferedReader(Reader in) - 根据参数指定的引用构造对象。
- Reader是个抽象类，实参传递子类的对(InputStreamReader)。
String readLine() - 用于读取一行文本。
void close() - 关闭流对象并释放资源

1.6 PrintStream类

(1)基本概念 java.io.PrintStream类用于打印各种数据内容。
(2)常用的方法 PrintStream(OutputStream out) - 根据参数指定的引用构造对象。
- OutputStream类是个抽象类，实参需要传递子类的对象。 >void print(String s) - 打印参数指定的字符串。 void println(String x) - 打印字符串并换行。 void close() -
关闭流。 void flush() - 刷新流对象。

1.7 ObjectOutputStream类

(1)基本概念   java.io.ObjectOutputStream类用于将一个对象整体写入到输出流中。   只能将支持 java.io.Serializable 接口的对象写入流中。   类通过实现 java.io.Serializable 接口以启用其序列化(将整个对象的所有信息转换为字节流信息的过程)功能。(2)常用的方法   ObjectOutputStream(OutputStream out) - 根据参数指定的引用构造对象。      - OutputStream类是抽象类，实参传递该类的子类对象。   void writeObject(Object obj) - 将参数指定的对象整体写入到流中。   void flush() - 刷新流对象。   void close() - 关闭流对象。

1.8 ObjectInputStream类

(1)基本概念   java.io.ObjectInputStream类用于将文件的对象整体读取出来。(2)常用的方法   ObjectInputStream(InputStream in) - 根据参数指定的引用构造对象。      - InputStream类是个抽象类，实参需要传递子类的对象。   Object readObject()  - 用于读取输入流中的一个对象并返回。      - 无法根据返回值来判断是否读取到文件的末尾。   void close() - 关闭流对象。

经验：
当需要向文件中写入多个对象时，通常的做法是先将所有被写入的对象放入一个集合中，然后将该集合整体看做一个对象写入文件中，此时读取文件中的内容时，只需要调用一次readObject()方法就可以全部读出。

7.字符流与字节流转换

转换流的特点：
1.其是字符流和字节流之间的桥梁
2.可对读取到的字节数据经过指定编码转换成字符
3.可对读取到的字符数据经过指定编码转换成字节 何时使用转换流？
1.当字节和字符之间有转换动作时；

2.流操作的数据需要编码或解码时。

具体的对象体现：
1.InputStreamReader:字节到字符的桥梁
2.OutputStreamWriter:字符到字节的桥梁 这两个流对象是字符体系中的成员，它们有转换作用，本身又是字符流，所以在构造的时候需要传入字节流对象进来。

8.File类

File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。
File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。

9.RandomAccessFile类

该对象并不是流体系中的一员，其封装了字节流，同时还封装了一个缓冲区（字符数组），通过内部的指针来操作字符数组中的数据。 该对象特点：
1.该对象只能操作文件，所以构造函数接收两种类型的参数：a.字符串文件路径；b.File对象。
2.该对象既可以对文件进行读操作，也能进行写操作，在进行对象实例化时可指定操作模式(r,rw)

代码：

---

键入public static void main(String[] args) {//1.创建BufferedReader类型的对象与键盘输入(System.in)进行关联BufferReader br=new BufferReader(new InputStreamReader(System.in));PrintStream ps=new Println(new FileOutputStream("c:/a.txt"));//3.不断地提示用户输入并读取一行本文，并且写入到c:/a.txt中int flage=1;while(true){    System.out.println();    String str=br.readLine();    if("byte".equals(str))break;    Date d=new Date();    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh24:mm:ss");    ps.println(sdf.format(d)+(flage%2==0? "张三说:":"李四说：")+str);    flage++;}ps.flush();ps.close();br.close();

读取数据

public static void main(String[] args){    //1.创建DataInputStream类的对象与参数指定的文件关联    DataInputStream dis=new DataInputStream(new FileInputStream("c:/a.txt"));    //2.读取文件中的一个int类型数据并打印出来    int res=dis.readInt();    System.out.println("res="+res);    dis.close();}

public static void main(String[] args) {    //1.创建DataOutputStream的对象与参数指定的文件进行关联    DataOutputStream dos = new DataOutputStream(                    new FileOutputStream("c:/a.txt"));    //2.将整数数据66写入文件    dos.writeInt(88);    //3.关闭输出流对象    dos.close();}

目录文件打印

public class TestDirPrint {    //打印指定目录中的内容，要求子目录中的内容也要打印出来    public static void dirPrint(File f){        //1.若f关联的是普通文件，则直接打印文件名即可        if(f.isFile()){            System.out.println(f.getName());        }        //2.若f关联的是目录文件，则打印目录名的同时使用[]括起来        if(f.isDirectory()){            System.out.println("[" + f.getName() + "]");            //3.获取该目录中的所有内容，分别进行打印            File[] ff = f.listFiles();            for(File ft : ff){                dirPrint(ft);            }        }       }

public static void main(String[] args) {        // TODO Auto-generated method stub        TestDirPrint.dirPrint(new File("D:/java09/day16"));        System.out.println(10/0);    }}**复制文件**public class TestFileCopy {    public static void main(String[] args) {        try{            //1.建立FileInputStream类的对象与源文件建立关联            FileInputStream fis                 = new FileInputStream("D:/java09/day16/javaseday16-IO流常用的类-06.wmv");            //2.建立FileOutputStream类的对象与目标文件建立关联            FileOutputStream fos = new FileOutputStream("c:/javaseday16-IO流常用的类-06.wmv");            //3.不断地读取源文件中的内容并写入到目标文件中            /* 可以实现文件的拷贝，但是文件比较大时效率很低            int res = 0;            while((res = fis.read()) != -1){                fos.write(res);            }            */            //第二种方案，根据源文件的大小准备对应的缓冲区(数组)，可能导致内存溢出            //第三种方案，无论文件的大小是多少，每次都准备一个1024整数倍的数组            byte[] data = new byte[1024 * 8];            int res = 0;            while((res = fis.read(data)) != -1){                fos.write(data, 0, res);            }            System.out.println("拷贝文件结束！");            //4.关闭文件输入流对象            fis.close();            //5.关闭文件输出流对象            fos.close();        }catch(Exception e){            e.printStackTrace();        }    }}

public class TestFileInputStream {    public static void main(String[] args) {        try{            //1.创建FileInputStream类的对象与指定的文件关联            FileInputStream fis = new FileInputStream("c:/a.txt");            //2.读取文件中的内容并打印            /*            int res = fis.read();            System.out.println("读取到的一个字节是：" + res); //h            System.out.println("\'h\'的ASCII值是：" + (int)'h');            res = fis.read();            System.out.println("读取到的一个字节是：" + res); //e            System.out.println("\'h\'的ASCII值是：" + (int)'e');            */            /*            int res = 0;            while((res = fis.read()) != -1){                System.out.println("读取到的一个字节是：" + (char)res); //            }*/            byte[] data = new byte[10];            int res = fis.read(data);            System.out.println("实际读取到的数据大小是："                 + res + ",读取到的文件内容是：" + new String(data, 0, res)                 + "!");            //3.关闭流对象并释放资源            fis.close();        }catch(Exception e){                e.printStackTrace();        }    }}

创建文件写入数据

public class TestFileOutputStream {    public static void main(String[] args) {        try{            //1.创建FileOutputStream类的对象，与指定的文件关联            //若文件不存在，则自动创建新的空文件            //FileOutputStream fos = new FileOutputStream("c:/a.txt", true);            fos.write("hello".getBytes());            System.out.println("写入数据成功！");            //3.刷新缓冲区并关闭流对象            fos.flush();            fos.close();        }catch(Exception e){            e.printStackTrace();        }    }}

读取对象object

public class TestObjectInputStream {    public static void main(String[] args) {        try{            //1.创建ObjectInputStream类型的对象与指定的文件关联            ObjectInputStream ois = new ObjectInputStream(                    new FileInputStream("c:/user.dat"));            //2.读取文件中的一个对象并打印出来            Object obj = ois.readObject();            if(obj instanceof User){                User user = (User)obj;                System.out.println(user);            }            //3.关闭流对象            ois.close();        }catch(Exception e){            e.printStackTrace();        }    }}

public class TestObjectOutputStream {    public static void main(String[] args) {        try{            //1.创建ObjectOutputStream类的对象与指定的文件关联            ObjectOutputStream oos = new ObjectOutputStream(                    new FileOutputStream("c:/user.dat"));            //2.准备User类型的对象并进行初始化            User user = new User("Mark", "123456", "[e-mail]");            //3.将User类型的对象整体写入到文件中            oos.writeObject(user);            System.out.println("写入对象成功！");            //4.关闭输出流对象            oos.flush();            oos.close();        }catch(Exception e){            e.printStackTrace();        }    }}