在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流....流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。

Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示（每种流包括输入和输出两种所以一共四个）：InputStream,OutputStream,Reader,Writer。Java中其他多种多样变化的流均由它们派生出来的。

import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.Reader;public class InputStreamTest {    /**     * @param args     */    public static void main(String[] args) {        String fileName = "D:/newTemp.txt";        InputStreamTest.readFileByBytes(fileName);        InputStreamTest.readFileByChars(fileName);           }    /**     * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。     *      * @param fileName     */    public static void readFileByBytes(String fileName) {        File file = new File(fileName);        InputStream in = null;        try {            System.out.println("以字节为单位读取文件内容，一次读一个字节：");            // 一次读一个字节            in = new FileInputStream(file);            int tempbyte;            while ((tempbyte = in.read()) != -1) {                System.out.write(tempbyte);            }            // 关闭文件输入流            in.close();        } catch (IOException e) {            e.printStackTrace();        }        try {            System.out.println("以字节为单位读取文件内容，一次读多个字节：");            // 一次读多个字节,创建一个长度为1024的字节数组来存取            byte[] tempbytes = new byte[1024];            // 用于保存实际读取的字节数            int byteread = 0;            in = new FileInputStream(fileName);            // 读入多个字节到字节数组中，byteread为一次读入的字节数            // 使用循环来进行重复读取            while ((byteread = in.read(tempbytes)) != -1) {                System.out.write(tempbytes, 0, byteread);            }        } catch (Exception e) {            e.printStackTrace();        } finally {            if (in != null) {                try {                    // 关闭文件输入流                    in.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }    /**     * 以字符为单位读取文件，常用于读文本，数字等类型的文件     *      * @param fileName     */    public static void readFileByChars(String fileName) {        File file = new File(fileName);        Reader reader = null;        try {            System.out.println("以字符为单位读取文件内容，一次读一个字节：");            // 一次读一个字符            reader = new InputStreamReader(new FileInputStream(file), "gbk");            int tempchar;            while ((tempchar = reader.read()) != -1) {                // 对于windows下，/r/n这两个字符在一起时，表示一个换行。                // 但如果这两个字符分开显示时，会换两次行。                // 因此，屏蔽掉/r，或者屏蔽/n。否则，将会多出很多空行。                if (((char) tempchar) != '\r') {                    System.out.print((char) tempchar);                }            }            // 关闭文件输入流            reader.close();        } catch (Exception e) {            e.printStackTrace();        }        try {            System.out.println("以字符为单位读取文件内容，一次读多个字节：");            // 一次读多个字符            char[] tempchars = new char[30];            int charread = 0;            reader = new InputStreamReader(new FileInputStream(fileName), "gbk");            // 读入多个字符到字符数组中，charread为一次读取字符数            while ((charread = reader.read(tempchars)) != -1) {                System.out.println(new String(tempchars, 0, charread));            }        } catch (Exception e1) {            e1.printStackTrace();        } finally {            if (reader != null) {                try {                    // 关闭文件输入流                    reader.close();                } catch (IOException e1) {                }            }        }    }}

上面要注意一个问题：字节流是根据字节来读取的，而一个中文是占两个字节的，如果包含很多中文的文件被字节流分多次进行读取，可能会造成乱码，因为有可能会导致刚好将一个中文分两次读取，这样就会乱码了，因此如果中文包含多的话还是使用字符流比较好。

在字节流与字符流之间选择的规律：如果需要进行输入/输出的内容是文本内容，则应该考虑使用字符流，如果需要进行输入/输出的是二进制内容，则应该考虑使用字节流，因为字节流的功能比字符流强大，计算机中所有的数据都是二进制的，而字节流可以处理所有的二进制文件。

与输入流一样，下面是输出流的演示：

import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileWriter;import java.io.IOException;import java.io.OutputStreamWriter;public class OutputStreamTest {    /**     * @param args     */    public static void main(String[] args) {        OutputStreamTest.writeFileByBytes();        OutputStreamTest.writeFileByChars();    }    /**     * 以字节为单位输出     */    private static void writeFileByBytes() {        // 创建字节输入流        FileInputStream fis = null;        // 创建字节输出流        FileOutputStream fos = null;        try {            fis = new FileInputStream("D:/newTemp.txt");            fos = new FileOutputStream("D:/newTemp2.txt");            // 一次读多个字节,创建一个长度为40的字节数组来存取            byte[] bytes = new byte[40];            // 用于保存实际读取的字节数            int hasRead = 0;            // 循环从输入流中读取数据            while ((hasRead = fis.read(bytes)) != -1) {                // 每读取一个，即写入文件输出流，读了多少就写多少                fos.write(bytes, 0, hasRead);            }        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        } finally {            // 关闭输入输出流            if (fis != null) {                try {                    fis.close();                } catch (IOException e) {                    e.printStackTrace();                }            }            if (fos != null) {                try {                    fos.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }    /**     * 以字符为单位输出     */    public static void writeFileByChars() {        // 创建字符输出        FileWriter fw = null;        try {            fw = new FileWriter("D:/newTemp3.txt");            fw.write("Hello world!\r\n");            fw.write("JAVA");        } catch (IOException e) {            e.printStackTrace();        } finally {            // 关闭输出流            if (fw != null) {                try {                    fw.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }        // 同样可以这样        // 创建字符输出        OutputStreamWriter osw = null;        try {            //创建一个节点输出流            FileOutputStream fos = new FileOutputStream("D:/newTemp4.txt");            //以OutputStreamWriter处理流来包装FileOutputStream节点流            osw = new OutputStreamWriter(fos);            osw.write("Hello world!\r\n");            osw.write("Hello world!\r\n");        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        } finally {            // 关闭输出流            if (osw != null) {                try {                    osw.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }}

上面出现了节点流与处理流，区分节点流于处理流的方法是：只要流的构造器的参数不是一个物理节点，而是已存在的流，那这个流一定是处理流，因为所有的节点流都是直接以物理io节点作为构造器的参数。

将节点流封装成处理流很简单，只需调用处理流的构造方法来传入节点流就可以了；而且看到上面流的关闭只是关闭了处理流而未去关闭节点流，这样做是完全正确的，以后我们在关闭流的时候只需要关闭最上层的处理流即可。