Java基础之IO流(二)

JAVA的IO流，平时使用的也比较多，但是对于其具体分类和继承体系知道的并不多，于是去看了相关的API文档，找出其中的关系和各自的应用情形。本文简单对常用的IO流进行分类整理，并简单举例说明其应用。希望本文对你有所帮助。

字符流和字节流是流的一种划分，按处理照流的数据单位进行的划分。
（A）
（1）字节流：对应抽象类为InputStream（输入流）和 OutputStream（输出流）。
（2）字符流：对应抽象类为Reader（输入流）和Writer（输出流）。
具体实现如下
（1）字节流：（常用的）FileInputStream实现了InputStream。
（常用的）FileOutputStream实现了OutputStream。
（2）字符流：（常用的）BufferedReader、InputStreamReader、 StringReader实现了Reader，FileReader继承了InputStreamReader。
（常用的）BufferedWriter、OutputStreamWriter、StringWriter实现了Writer，FileWriter继承了OutputStreamWriter。

输入流是得到数据，输出流是输出数据。
（B）实现类详情及使用情况如下：

输入流：

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

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

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

    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);  
            String str = null;
            while ((str = reader.readLine())!= null) {  
                System.err.println(str);  
            }  
            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 copyFileOne(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 void copyFileTwo(String oldPath, String newPath) {   
               try {   
                   int byteread = 0;   
                   File oldfile = new File(oldPath);   
                   String str = null;
                   if (oldfile.exists()) {                  //文件存在时    
                       FileReader in = new FileReader(oldfile);
					   FileWriter out = new FileWriter(newPath);
					   BufferedReader reader = new BufferedReader(in);
					   BufferedWriter writer = new BufferedWriter(out);
		               while((str = reader.readLine())!=null){
			                writer.write(str);
		               }
                       writer.close();   
                       reader.close();  
                       out .close();
                       in.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) {  
                    }  
                }  
            }  
        }  
    }