Java之IO流总结

IO流
·Java流式输入/输出原理
·Java流类的分类
·输入/输出流类
·常见的节点流和处理流
·文件流
·缓冲流
·转换流
·数据流
·Print流
·Object流

①Java流式输入/输出原理
    
        00101...-->
    文件 ------------------ 程序

<-- ...00101
    文件 ------------------ 程序
    
           00101...-->
    网络连接 ------------------ 程序

00101...-->
    程序 ------------------ 程序

00101...-->  “Hello”
    文件 -----------============== 程序 （从0101等转换为字符，一层包一层）

②流的分类
    java.io包中
        ·按数据流的方向不同可以分为输入流、输出流
        ·按处理数据单位不同可以分为字节流、字符流
        ·按照功能不同可以分为节点流、处理流

所有流类型位于包java.io内都分别继承以下四种抽象流类型

字节流        字符流
    ------------------------------------------
    输入流          InputStream      Reader
    输出流          OutputSteam      Writer

字节流（8bit）

|----FileInputStream(节点流)
             |
             |----PipedInputStream(节点流)     |---LineNumberInputStream(处理流)
             |                          |       
             |----FilterInputStream(处理流)-------|---DataInputStream(处理流)
             |                     |
    InputStream -|----ByteArrayInputStream(节点流)    |---BufferedInputStream(处理流)
             |                     |---PushbackInputStream(处理流)        
             |----SequenceInputStream(处理流)
             |
             |----StringBufferInputStream(节点流)
             |
             |----ObjectInputStream(处理流)

InputStream的基本方法
        //读取一个字节并以整数的形式返回（0-255）
        //如果返回-1已到输入流的末尾
    ·int read() throws IOExcetion

//读取一系列字节并存储到一个数组buffer
        //返回实际读取的字节数，如果读取器前已到输入流的末尾返回-1
    ·int read(byre[] buffer) throws IOExcetion

//读取length个字节
        //并存储到一个字节数组buffer，从length位置开始
        //返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
        //buffer - 读入数据的缓冲区。
        //offset - 数组 buffer 中将写入数据的初始偏移量。
        //length - 要读取的最大字节数。
    ·int read(byte[] buffer, int offset, int length) throws IOExcetion

//关闭流释放内存资源
    ·void close() throws IOExcetion

//跳过n个字节不读，返回实际跳过的字节数
    ·long skip(long n) throws IOExcetion

字节流（8bit）

|----FileOutputStream(节点流)
             |
             |----PipedOutputStream(节点流)    
             |                          |       
             |----FilterOutputStream(处理流)-----|---DataOutputStream(处理流)
             |                     |
       OutputStream -|----ByteArrayOutputStream(节点流)  |---BufferedOutputStream(处理流)
             |                     |---PrintStream(处理流)        
             |
             |----ObjectOutputStream(处理流)

OutputStream的基本方法
        //向输出流中写入一个字节数据，该字节数据为参数b的低8位
    ·void write(int b) throws IOException
    
        //将一个字节类型的数组中的数据写入输出流
    ·void write(byre[] b) throws IOException

//将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
    ·void write(byre[] b, int off, int len) throws IOException

//关闭流释放内存资源
    ·void close() throws IOException

//将输出流中缓冲的数据全部写出到目的地
    ·void flush() throws IOException

注意：先flush，在close

字符流（16bit）

|----BufferedReader(节点流)----LineNumberReader(处理流)
             |
             |----CharArrayReader(处理流)    
             |                              
             |----InputStreamReader(处理流)-----FileReader(节点流)
             |                    
             Reader -|----FilterReader(处理流)----PushbackReader(处理流)
             |                         
             |
             |----PipedReader(节点流)
             |
             |----StringReader(节点流)

Reader的基本方法
        //读取一个字符并以整数的形式返回（0-255）
        //如果返回-1已到输入流的末尾
    ·int read() throws IOExcetion

//读取一系列字符并存储到一个数组buffer
        //返回实际读取的字符数，如果读取器前已到输入流的末尾返回-1
    ·int read(byre[] buffer) throws IOExcetion

//读取length个字符
        //并存储到一个字符数组buffer，从length位置开始
        //返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
        //buffer - 读入数据的缓冲区。
        //offset - 数组 buffer 中将写入数据的初始偏移量。
        //length - 要读取的最大字符数。
    ·int read(byte[] buffer, int offset, int length) throws IOExcetion

//关闭流释放内存资源
    ·void close() throws IOExcetion

//跳过n个字符不读，返回实际跳过的字节数
    ·long skip(long n) throws IOExcetion

字符流（16bit）

|----BufferedWriter(处理流)
             |
             |----CharArrayWriter(节点流)    
             |                              
             |----OutputStreamReader(处理流)-----FileWriter(节点流)
             |                    
             Writer -|----FilterWriter(处理流)
             |                         
             |
             |----PipedWriter(节点流)
             |
             |----StringWriter(节点流)

Writer的基本方法
        //向输出流中写入一个字符数据，该字节数据为参数b的低8位
    ·void write(int b) throws IOException
    
        //将一个字符类型的数组中的数据写入输出流
    ·void write(char[] cbuf) throws IOException

//将一个字符类型的数组中的从指定位置（off）开始的len个字符写入到输出流
    ·void write(char[] cbuf, int off, int len) throws IOException

//将一个字符串中的字符写入到输出流
    ·void write(String string) throws IOException

//将一个字符串从offset开始的length个字符写入到输出流
    ·coid write(String string, int offset, int length) throws IOException

//关闭流释放内存资源
    ·void close() throws IOException

//将输出流中缓冲的数据全部写出到目的地
    ·void flush() throws IOException

③输入/输出流
    1、输出流跟输入流
    一切以程序为中心
        ·从文件到程序为输入流
        ·从程序到文件为输出流
    2、字节流和字符流
        ·字节（8bit）
        ·字符（16bit）
        ·一个字符等于2个字节
    3、节点流和处理流
        ·处理流是包在节点流的一层“管道”

④常见的节点流和处理流
    ·节点流为可以从一个特定的数据源（节点）读写数据（如：文件，内存）
            节点流
        数据源 -------------------- 程序
        
    ·处理流是连接在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能

-->
        数据源 -------======== 程序
            
            <--
        程序 ============-------- 数据源

⑤节点流----文件流
    字符流            字节流
---------------------------------------
输入流    FileReader    FileInputStream
输出流    FileWriter    FileOutputStream

访问文件
    从文件到程序，输入流
    ·使用FileInputStream

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        try {
            //连接管道
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //读取数据
            try {
                while((b = fis.read())!= -1){
                    System.out.print((char)(b));
                    
                }
                fis.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}
    显示结果
    package Demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        try {
            //????????
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //????????
            try {
                int num = 0;
                while((b = fis.read())!= -1){
                    System.out.print((char)(b));
                }
                fis.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}

发现出现？？？？？，问题是汉字是一个字符（两个字节），用的是字节流，一个字节一个字节读取，
所有中文翻译不出来，改为Reader可以
    
    从程序到文件
    ·使用FileOutputStream
    package Demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        int b = 0;
        FileInputStream fis = null;
        FileOutputStream fot = null;
        try {
            //连接管道
            fis = new FileInputStream("G://Java2014Project//JavaDemo1//src//Demo01/Login.java");
            fot = new FileOutputStream("C://Users//woshishabi//Desktop//test.txt");
        } catch (FileNotFoundException e) {
            System.out.println("error");
        }
        //读取数据
            try {
                while((b = fis.read())!= -1){
                    fot.write(b);
                }
                fis.close();
                fot.close();
            } catch (IOException e) {
                System.out.println("error");
            }
        
    }
}

桌面上多了一个Test.txt文本，

·使用FileReader：字符输入流，从文件到程序
        ......
    ·使用FileWriter：字符输出流，从程序到文件
        ......

⑥处理流----缓冲流
    ·缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，
同时增加了一些新的方法
    ·J2SDK提供了四种缓存流，其常用的构造方法为：
            //字符输入缓冲流
        BufferedReader(Reader in)
        BufferedReader(Reader in, int sz) //sz为自定义缓存区的大小    
            
            //字符输出缓冲流
        BufferedWriter(Writer out)
        BufferedWriter(Writer out,int sz)
        
            //字节输入缓冲流
        BufferedInputStream(InputStream in)
        BufferedInputStream(InputStream in, int size)
    
            //字节输出缓冲流
        BufferedOutputStream(OutputStream out)
        BufferedOutputStream(OutputStream out, int size)

·缓冲输入流支持其父类的mark和reset方法    mark：直接从多少个字符开始读取  reset：回到刚才标记的点
    ·bufferedReader提供了readline方法用于读取一行字符串（以\r或\n分隔）
    ·bufferedWriter提供了newLine用于写入一个行分隔符
    ·对于输出的缓冲流，写出的数据会现在内存中缓存，使用flush方法将会使内存中的数据立刻写出

bufferedReader和bufferedWriter使用

package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Login{
    public static void main(String[] args){
        try {
            //从文件写入数据
            BufferedReader br  = new BufferedReader(new FileReader("G://Java2014Project//JavaDemo1//src//Demo01//Login.java"));
            BufferedWriter bw = new BufferedWriter(new FileWriter("C://Users//woshishabi//Desktop//Test.txt"));
            //从文件读取数据
            String s = null;
            while((s = br.readLine()) != null){
                System.out.println(s);
                bw.write(s);
                bw.newLine();
            }
            bw.flush();
            br.close();
            bw.close();
        }
            catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
    }
}

⑦处理流----转换流
    ·InputStreamReader和OutputStreamWriter用与字节数据到字符数据之间的转换
    ·InputStreamReader需要和InputStream“套接”
    ·OutputStream需要和OutputStream“套接”
    ·转换流在构造时可以指定其编码集合，例如
        InputStream isr = new InputStreamReader(System.in, "ISO8859_1");

范例：OutputStreamWriter

package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        try {
            //将输出字节流转换为字符流
            OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt"));
            //向文件中输入字符串
            osw.write("sdfjaksldjflskdjflaskdjfsakjdf");
            //读取字符编码
            System.out.println(osw.getEncoding());
            osw.close();
            //在文本后面添加字符串，不覆盖，则true，否则写false， 后面可以自定义编码
            osw = new OutputStreamWriter(new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt", true), "UTF-8");
            osw.write("qwqeqweqweqeq");
            System.out.println(osw.getEncoding());
            osw.close();
        }
            catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }

范例：InputStreamReader

package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        //从键盘读取数据
        InputStreamReader isr = new InputStreamReader(System.in);
        //字符输入缓冲流
        BufferedReader br = new BufferedReader(isr);
        String s = null;
        try {
            //读取一行字符
            s = br.readLine();
            while(s != null){
            if(s.equalsIgnoreCase("exit")){     //将一个字符串与另一个字符串比较，不考虑大小写
                break;    
            }
            //将小写转换为大写
                System.out.println(s.toUpperCase());
                s = br.readLine();
            }
            br.close();
            
            }
         catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

⑧数据流----DataInputStream...
    ·DataInputStream 和 DataOutputStream 分别继承了InputStream 和 OutputStream，属于处理流，
需要分别套接在InputStream 和 OutputStream类型的节点流觞
    ·DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的Java原始数据类型（int、double等）
的方法
    ·DataInputStream 和 DataOutputStream 的构造方法为：
        ·DataInputStream（InputStream in）
        ·DataOutputStream（OutputStream out）
    
范例：使用DataInputStream 和 DataOutputStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Login{
    public static void main(String[] args){
        //一个字节数组输出流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //在字节数组输出流上套接一个数据流，能传递基本数据类型
        DataOutputStream dos = new DataOutputStream(baos);
        try {
            //向字节数组写入一个随机数
            dos.writeDouble(Math.random());
            dos.writeBoolean(true);
            //创建一个字节数组输入流
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            //输出字节数组中有多少个字节
            System.out.println(bais.available());
            //将处理流包在字节数组输入流上，输出基本数据
            DataInputStream dis = new DataInputStream(bais);
            //输出double，先输入的先输出
            System.out.println(dis.readDouble());
            //输出boolean
            System.out.println(dis.readBoolean());
            dos.close();
            dis.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

⑨print流    PrintStream主要操作byte流，而PrintWriter用来操作字符流
    ·PrintWriter 和 PrintStream都属于输出流，分别针对与字符和字节
    ·PrintWriter 和 PrintStream提供了重载的print
    ·Println方法用于多种数据类型的输出
    ·PrintWriter 和 PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息
    ·PrintWriter 和 PrintStream有自动flush功能
构造方法：
    ·PrintWriter(Writer out)
    ·PrintWriter(Writer out，boolean autoFlush)
    ·PrintWriter(OutputStream out， boolean autoFlush)
    ·PrintStream(OutputStream out)
    ·PrintStream(OutputStream out， boolean autoFlush)

范例：PrintStream
package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class Login{
    public static void main(String[] args){
        PrintStream ps = null;
        try {
            //文件字节输出流
            FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
            //输出流
            ps = new PrintStream(fos);
            if(ps != null){
                //使system.out指向了文件Test.txt
                System.setOut(ps);
            }
            for (int i = 0; i < 100; i++) {
                System.out.print(i + ",");
            }

} catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

范例：PrintWriter

package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Date;

public class Login{
    public static void main(String[] args){
        String s = null;
        //从键盘输入，字节转字符的转换流上套接缓冲流
        BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
        try {
            //输出流，输出到文件，不覆盖
            FileWriter fw = new FileWriter("C://Users//woshishabi//Desktop//Test.txt",true);
            //输出流，套接在文件输出流上
            PrintWriter pw = new PrintWriter(fw);
            //接收键盘输入的一行数据，
            while((s = bis.readLine()) != null){
                //判断是否为exit，是则结束while
                if(s.equalsIgnoreCase("exit"))break;
                //小写转大写，在dos中输出
                System.out.println(s.toUpperCase());
                //在目标文件里面输出数据
                pw.println("------");
                pw.println(s.toLowerCase());
                pw.flush();
            }
            //在目标文件中输出日期
            pw.println("-----"+ new Date() + "------");
            pw.flush();
            pw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

⑩Object流
    ·直接将Object写入或读出
        ·transient关键字（透明的）：修饰属性， transient int k  = 15;   输出结果k = 0；在序列化的时候不考虑，不写入硬盘
        ·serializable接口：（标记性接口，里面什么都没有）
        ·extemalizable接口：
    注意：如果需要使用对象流，必须实现serializable接口

范例：
    package Demo01;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.Date;

public class Login{
    public static void main(String[] args){
        T t = new T();
        t.k = 40;
        try {
            //文件输出流，
            FileOutputStream fos = new FileOutputStream("C://Users//woshishabi//Desktop//Test.txt");
            //在文件输出流上套接一个对象输出流，从程序传递一个对象到目标文件中
            ObjectOutputStream  oos = new ObjectOutputStream(fos);
            //写入对象
            oos.writeObject(t);
            //文件输入流，锁定目标文件
            FileInputStream fis = new FileInputStream("C://Users//woshishabi//Desktop//Test.txt");
            //在文件输入流上套接一个对象输入流，从目标文件中取出对象的通道
            ObjectInputStream ois = new ObjectInputStream(fis);

//取出对象
            T t1 = (T) ois.readObject();
            //打印到屏幕上
            System.out.println(t1.i + " " + t1.j + " " + t1.k + " " + t1.z);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

}
}

class T implements Serializable{
    int i = 1;
    int j = 2;
    double z = 9.0;
    int k = 14;

}

总结：
    ·InputStream/OutputStream

·Reader/Writer

·FileInputStream/FileoutputStream

·FileReader/FileWriter

·BufferedInputStream/BufferedOutoutStream

·BufferedTeader/BufferedWriter

·ByteArrayInputStream/ByteArrayOutputStream

·InputStreamReader/OutputStreamWriter

·DataInputStream/DataOutputStream

·PrintStream/PrintWriter

·ObjectInputStream/ObjectOutputStream