java中的io流

       平时开发的时候在使用io流有时候不是很多，即使是有人用过，可能对于其具体分类和继承体系可能知道的并不多，也很少有人去看相关的API文档（项目时间紧，天天加班，没办法），找出其中的关系和各自的应用情形。笔者最近看了一些java视频，所以打算简单对常用的IO流进行分类整理，并简单举例说明其应用。希望本文能够对你有所帮助。

（1）java中的IO流大致分为两种：
        （1）字节流：对应抽象类为InputStream（输入流）和 OutputStream（输出流）。 
        （2）字符流：对应抽象类为Reader（输入流）和Writer（输出流）。 


（2）其具体实现如下： 
        （1）字节流：（常用的）FileInputStream实现了InputStream。
                               （常用的）OutputStream实现了FileOutputStream。 
        （2）字符流：（常用的）BufferedReader、InputStreamReader、 StringReader实现了Reader，FileReader继承了InputStreamReader。
                               （常用的）BufferedWriter、OutputStreamWriter、StringWriter实现了Writer，FileWriter继承了OutputStreamWriter。


（3）实现类详情及使用情况如下：
        输出流：
        （1）OutputStreamWriter是字符流通向字节流的桥梁：使用指定的 charset 将要向其写入的字符编码为字节。它使用的字符集可以由名称指定或显式给定，否则可能接受平台默认的字符集。 每次调用 write() 方法都会针对给定的字符（或字符集）调用编码转换器。在写入基础输出流之前，得到的这些字节会在缓冲区累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。为了达到最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中以避免频繁调用转换器。例如： 
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        （2）FileReader 用来读取字符文件的便捷类，用于读取字符流。
        （3）BufferedReader具有缓冲区，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 
        （4）StringReader  一个字符串的字符输入流。 
        （5）FileInputStream 要读取原始字节流。常用于读二进制文件，如图片、声音、影像等文件比如我们经常看的，就可以被读取。


        输入流：
        （1）InputStreamReader是字节流通向字符流的一座桥梁：它使用指定的 charset 读取字节并将其解码为字符。每次调用里的 read() 方法都会导致从基础输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从基础流读取更多的字节，使其超过满足当前读取操作所需的字节。平时我们开发的时候，为了达到最高效率，可以考虑在 BufferedReader 内包装 InputStreamReader。比如： BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        （2）FileWriter 用来写入字符文件的便捷类。
        （3）BufferedWriter  具有缓冲区，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
        （4）StringWriter  一个字符串的字符输出流，可以用其回收在字符串缓冲区中的输出来构造字符串。 
        （5）FileOutputStream 写入原始字节流。常用于读二进制文件，如图片、声音、影像等文件。


（4）代码实例分析如下：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import org.junit.Test;

public class TestStream {
    // 读取文件中字符
    @Test
    public void testRead() throws IOException {
        String path = "read.txt";
        FileReader read = new FileReader(path);
        BufferedReader reader = new BufferedReader(read);
        while (reader.readLine() != null) {
            String s = reader.readLine();
            System.err.println(s);
        }
        reader.close();
    }

    // 写入字符到文件
    @Test
    public void testWrite() throws IOException {
        String path = "write.txt";
        FileWriter write = new FileWriter(path);
        BufferedWriter writer = new BufferedWriter(write);
        char[] buffer = new char[1024];
        for (int i = 0; i < 1024; i++) {
            if ((char) 'a' + i > Character.MAX_VALUE) {
                buffer[i] = 'z';
                System.err.println(1);
            } else {
                buffer[i] = (char) ('a' + i);
            }

        }
        writer.write(buffer);
        writer.close();
    }

    // 删除文件内容
    @Test
    public void testDelete() throws IOException {
        String path = "write.txt";
        FileWriter write = new FileWriter(path);
        BufferedWriter writer = new BufferedWriter(write);
        StringBuffer buffer = new StringBuffer();
        writer.write(buffer.toString());
        writer.close();
    }

    // 替换内容
    @Test
    public void testDeleteAndReplace() throws IOException {
        String path = "write.txt";
        FileWriter write = new FileWriter(path);
        BufferedWriter writer = new BufferedWriter(write);
        int i = 0;
        while (++i < 100) {
            StringBuffer buffer = new StringBuffer();
            buffer.append(Math.random());
            writer.write(buffer.toString() + "\r\n");
        }
        writer.close();
    }

    // 拷贝一个文件内容到另一个文件
    @Test
    public void copyFile(String oldPath, String newPath) {
     try {
     int byteread = 0;
     File oldfile = new File(oldPath);
     if (oldfile.exists()) { //文件存在时
     InputStream inStream = new FileInputStream(oldPath); //读入原文件
     FileOutputStream fs = new FileOutputStream(newPath);
     byte[] buffer = new byte[100];
                while ((byteread = inStream.read(buffer)) != -1) {
                       fs.write(buffer, 0, byteread);
     }
                   inStream.close();
                   fs.close();
     }
     } catch (Exception e) {
               e.printStackTrace();
     }
     }

    //读取字符流
    @Test
    public static void testReadByte() {
        String path = "write.txt";
        File file = new File(path);
        InputStream in = null;
        try {
            // 一次读一个字节
            in = new FileInputStream(file);
            int tempbyte;
            while ((tempbyte = in.read()) != -1) {
                System.out.write(tempbyte);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        try {
            // 一次读多个字节
            byte[] tempbytes = new byte[100];
            int byteread = 0;
            in = new FileInputStream(path);
            while ((byteread = in.read(tempbytes)) != -1) {
                System.out.write(tempbytes, 0, byteread);
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e1) {
                }
            }
        }
    }
}

总结一下，对于一些初学者来说，经常会被IO流这块搞晕，很多人在这块花费了大量的时间，但是效果也不是很好。给初学者一个建议，学习的时候不要扣的太深，点到即止即可，否则扣到疼了就不好了。等有了一些经验，达到了一个深度之后，再去扣，就会比较爽了。