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", "xiaomg@163.com");
            //3.将User类型的对象整体写入到文件中
            oos.writeObject(user);
            System.out.println("写入对象成功！");
            //4.关闭输出流对象
            oos.flush();
            oos.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}