流

输入流：
    输入流最抽象类：InputStream,Reader。他们是抽象类，定义了输入流的所有通用的方法。
        InputStream：字节输入流（流的单位是8位字节）
        Reader:字符输入流（流的单位是字符）
    read方法：
        InputStream中定有三个read方法：
            int read();     //读取一个字节
            int read(byte[] b);     //读取byte[]等长个字节的数据，存放到byte[]中。
            int read(byte[] b , int off , int len) ;    //读取len长度，存放到byte[]中，从byte[off]开始存放。返回读取的数量
        Reader中的三个read方法基本和InputStream相同，只不过单位是字符。
            int read();
            int read(char[] c);
            int read(char[] c , int off , int len);
        除了read方法还有一些关于操作流指针的方法：
    FileInputStream和FileReader:
        InputStream和Reader是抽象类,FileInputStream和FileReader是实现的子类之一：
            他们属于节点流（连接源和目的两个节点）数据源是文件。
        注意：
            1：如果使用字节流读取存放了GBK中文的文件，输出时会出现乱码，原因是一个GBK是两字节，字节流一次只读1个字节
            2：流资源使用后需要关闭，javaGC只清除内存资源，流资源不是。最好写在Finally{}中。

FileReader Demo:

package demo;
import java.io.*;
public class Demo {
    public static void main(String[] args) throws IOException {
        FileReader fr = null;
        try{
            //创建输入流
            fr = new FileReader("F:"+File.separator+"test.text");
            //创建一个接受字符的数组char[32]
            char [] cbuf = new char[32];
            //记录获取到的字符个数：
            int readLen = 0;
            //循环输入：
            while((readLen = fr.read(cbuf)) > 0){
                System.out.println("获取到的数据"+new String(cbuf,0,readLen));
            }
        }catch (IOException ioe){
            ioe.printStackTrace();
        }finally {
            if(fr != null){
                fr.close();
            }
        }
    }
}
//文件字节输入流类似

输出流：
　　OutPutStream 和 Writer
    输出流和输入非常类似，他们也提供了三了类似的方法：
        void write(int c);      //将指定的字节或者字符放到输出流中。
        void write(byte[]/cahr[] buf);      //将制定的字节数组/字符数组放到流中。
        void write(byte[]/char[] buf ,int off ,ing len);    //制定字节字符数组的指定长度方法流中。
        ***由于字节流传出的是Byte[]所以可以直接使用  void write(String str)和void write(String str , int off ,int len)
Demo:

package demo;
import java.io.*;
public class Demo {
//    使用输入流和输出流实现复制文件
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream("F:"+File.separator+"File"+File.separator+"test.txt");
            fileOutputStream = new FileOutputStream("F:"+File.separator+"File"+File.separator+"copy.txt");
            byte[] buf = new byte[32];
            int readCount;
            while((readCount = fileInputStream.read(buf)) > 0){
//            将读取到的数据写到输出流中。
                fileOutputStream.write(buf,0,readCount);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fileInputStream != null){
                fileInputStream.close();
            }
            if(fileOutputStream != null){
                fileOutputStream.close();
            }
        }
    }
}

处理流：
    由于字符流和字节流使用比较麻烦，实际使用时我们需要借助处理流。
    使用处理流可以忽略底层设备之间的差异，使程序员只关心输入输出的方法。
    典型的使用思路是：处理流封装节点流，和设备交互的任务又节点流执行，程序通过处理流来指定输入输出操作。（创建处理流是会传入一个节点流）
    例如：PrintStream 就是OutPutStream的一种实现。
    关闭了处理流，处理流封装的流自动关闭。
Demo:

package demo;
import java.io.*;
public class Demo {
    public static void main(String[] args){
        PrintStream printStream = null;
        try{
            //创建一个节点流。
            FileOutputStream fileOutputStream = new FileOutputStream("F:\File\copy.txt");
            //使用处理流封装这个节点流。
            printStream = new PrintStream(fileOutputStream);
            //使用处理流提供的简单的方法。
            printStream.print("这句话是使用printStream的print方法输出的。");
        }catch (IOException ioe){}
        finally {
            if(printStream != null){
                //关闭处理流，节点流自动关闭
                printStream.close();
            }
        }
    }
}

java 流体系介绍：
    java流体系规律性很强：
        输入流：字节输入流，字符输入流
        输出流：字节输出流，字符输出流。
        节点输入输出流，处理输入输出流。
     如图：
　　　　

文件输入输出流、字符创输入输出流、数组输入输出流：以文件、字符串、数组为源的流。
管道流：用于实现进程之前通信。
缓冲流：使用缓冲功能，提高了输入输出的效率，但是要使用flush()方法将管道中的内容刷出。
对象流：实现对象的序列化。

上图中的流只是java.io包中。java还有一些比较特殊的流用于处理影音、压缩/解压、加密/解密。