Java 的 IO 流

　　接着上一篇的 “Java 的 File 类” 的随笔，在File类的基础上，我们就走进Java的IO流吧。

流的概念和作用

　　流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

流的分类：

　　（1）、按照数据流向的不同分为：输入流（从磁盘、网络等读取到内存，只能读，不能写）、输出流（从内存写出到磁盘、网络，只能写，不能读）

　　（2）、按照处理数据的单位不同分为：字节流（以字节为基本操作单位）、字符流（以字符为基本操作单位）

　　（3）、按照角色的不同分为：节点流（向某个IO设备/节点（磁盘文件、网络等）直接读写数据，也称为低级流）、处理流（用于包装一个已存在的流，通过这个已存在的流来进行读写操作，并不直接操作IO节点，也称为高级流、包装流）

Java流类结构：

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
操作文件	FileInputStream	FileOutputStream	FileReader	FileWriter
操作数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
操作字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流（用于序列化）	ObjectInputStream	ObjectOutputStream
抽象基类（用于过滤）	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流（输出功能极其大）		PrintStream		PrintWriter

java的IO流的用法

InputStream是字节输入流的顶级父类，常用方法：

• int  read()     //读取一个字节，返回该字节数据的Unicode码值
• int  read(byte[]  buff)    //最多读取buff.length个字节，将读取的数据放在buff数组中，返回实际读取的字节数
• int  read(byte[]  buff, int off, int length)    //最多读取length个字节，放在buff数组中，从数组的off位置开始放置数据，返回实际读取的字节数。off一般设置为0，length一般设置为buff的长度。

        //1、创建一个File类的对象
        File file = new File("hello.txt");
        //2、创建一个FileInputStream类的对象
        FileInputStream fis = new FileInputStream(file);
        //3、调用FileInputStream的方法，实现file文件的读取
        int b = fis.read();
        while(b != -1){
            System.out.print((char)b+" ");
            b = fis.read();
        }
        fis.close();        

OutputStream是字节输出流的顶级父类，常用方法：

• void  write(int  i)    \输出一个字节，i是码值，即read()得到的码值，输出i对应的字节
• void  write(byte[]  buff)   //输出整个字节数组的内容
• void  write(byte[]  buff, int  off, int  length)    //把字节数组从off位置开始，输出长度为length字节的内容

        File file = new File("hello1.txt");
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream(file);
            fos.write(new String("
I Love CYT!").getBytes());
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

Reader时字符输入流的顶级父类，常用方法：

• int  read()     //读取一个字符，返回该字符的Unicode码值，注意并不是返回该字符。
• int  read(char[]  buff)   //最多读取buff.length个字符，放在buff数组中，返回实际读取的字符数
• int  read(char[]  buff, int  off, int  length） //最多读取length个字节，放在buff数组中，从数组的off位置开始放置数据，返回实际读取的字符数。off一般设置为0，length一般设置为buff的长度

          File file = new File("1.txt");
          FileReader fr = null;
          try{
              fr = new FileReader(file);
              char[] c = new char[24];
              int len;
              while((len = fr.read(c)) != -1){
                  for(int i=0;i<len;i++){
                      System.out.print(c[i]);
                  }
              }
          }catch(Exception e){
              e.printStackTrace();
          }finally{
              if(fr != null){
                  try {
                      fr.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
      }    

Writer是字符输出流的顶级父类，常用方法：

• void  write(int  i)    //输出一个字符，i是码值，输出的是i对应的字符
• void  write(char[]  buff)    //输出整个char[]的内容
• void  write(char[]  buff,  int  off,  int  length)      //把char[]从off位置开始，输出长度为length字符的内容

可以用String代替char[]，所以Writer还具有以下2个方法：

• void  write(String str)
• void  write(String str, int off, int length)

        FileWriter fw = null;
        try{
            fw = new FileWriter(new File("1.txt"));
            String str = "我喜欢Java,我要成为Java工程师。";
            fw.write(str);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

缓冲流是和4级顶级父类对应的：加前缀Buffered

　　InputStream   BufferedInputStream   字节输入缓冲流，可作为所有字节输入流类的缓冲流

　　OutputStream   BufferedOutputStream    字节输出缓冲流

　　Reader     BufferedReader    字符输入缓冲流

　　Writer　　BufferedWriter    字符输出缓冲流

//用 BufferedReader 把文件读进来， 再用 BufferedWriter 把内容写出去
        File file = new File("hello.txt");
        File file1 = new File("hello3.txt");
        FileReader fr = null;
        BufferedReader br = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            fr = new FileReader(file);
            fw = new FileWriter(file1);
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            String str;
            while((str = br.readLine()) != null){
//                System.out.println(str);
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

其他方法我就不一一说明了。有兴趣的同学可以自己再深入研究。

最后我就提供文件复制的通用方法吧。自己写的通用类。让自己更好的去了解Java的IO流的使用。

package io;
/*
 * 实现文件的复制
 */
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile {

    // 字节文件的复制方法
    public static void copyFileByte(String src, String dest) {
        // 1、提供读入、写出的文件
        File file1 = new File(src);
        File file2 = new File(dest);
        // 2、提供相应的流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            // 3、实现文件的复制
            byte[] b = new byte[20];
            int len;
            while ((len = fis.read(b)) != -1) {
                fos.write(b, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /*
     * 使用FileReader 、 FileWriter 可以实现文本文件的复制
     * 对于非文本文件(视频文件、音频文件、图片)，只能使用字节流复制。
     */
    public static void copyFileChar(String src, String dest) {
        // 1、提供读入、写出的文件
        File file1 = new File(src);
        File file2 = new File(dest);
        // 2、提供相应的流
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader(file1);
            fw = new FileWriter(file2);
            // 3、实现文件的复制
            char[] c = new char[24];
            int len;
            while ((len = fr.read(c)) != -1) {
                fw.write(c, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    //使用BufferedInputStream和BufferedOutputStream实现非文本文件的复制
    public static void copyFileBuffered1(String src, String dest) {
        //1、提供读入、写出的文件
        File file1 = new File(src);
        File file2 = new File(dest);
        //2、先创建相应的节点流:FileInputStream、 FileOutputStream
        FileInputStream fis = null;
        FileOutputStream fos = null;
        //3、再创建缓冲流:BufferedInputStream 、 BufferedOutputStream
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //4、具体实现文件复制的操作
            byte[] b = new byte[1024];
            int len;
            while((len = bis.read(b)) != -1){
                bos.write(b, 0, len);
                bos.flush();
            }
        }catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

现在自己也准备大四了，所以自己要捉紧时间去学习，博客里面有什么问题的可以跟我说一下，大家一起交流一下学习的经验。