Java基础之《流》

流
  Java流式输入/输出原理
    在Java程序中，对于数据的输入/输出操作以"流"(stream)方式进行；
    J2SDK提供了各种各样的"流"类，用以获取不同种类的数据；程序中通过
    标准的方法输入或输出数据

    从文件里取数据，文件相当于一个桶，在文件上接个管道，从管道里
    像水流一样取数据

  Java流类的分类
    java.io包中定义了多个流类型（类或抽象类）来实现输入/输出功能；
    可以从不同的角度对其进行分类：
    1）按数据流的方向不同可以分为输入流和输出流
    2）按处理数据单位不同可以分为字节流和字符流
    3）按照功能不同可以分为节点流和处理流

    J2SDK所提供的所有流类型位于包java.io内都分别继承自以下四种抽象
    流类型
              字节流     字符流
    输入流：InputStream   Reader
    输出流：OutputStream  Writer
    说输入流输出流都是站在程序的角度上

    字节流：直接读二进制010101，8位一读一个字节长度，凡是以stream结尾的都是字节流
    字符流：一个字符一个字符往外读，两个字节一读

    节点流：这根管道直接连接在数据源上
    处理流：套在其它管道之上的管道，包在其它管道之上

  输入/输出流类

    InputStream的基本方法

    //读取一个字节并以整数的形式返回(0~255)
    //如果返回-1已到输入流的末尾。
    int read() throws IOException

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

    //读取length个字节
    //并存储到一个字节数组buffer,从offset位置开始
    //返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
    int read(byte[] buffer, int offset, int length)
                          throws IOException

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

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


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

    //将一个字节类型的数组中的数据写入输出流
    void write(byte[] b) throws IOException

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

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

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

    Reader
    继承自Reader的流都是用于向程序中输入数据，且数据的单位为

    字符（16 bit）用于读汉字

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

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

    //读取length个字符
    //并存储到一个数组buffer,从offset位置开始
    //返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
    int read(char[] cbuf, int offset, int length)
                         throws IOException

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

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

    Writer
    继承自Writer的流都是用于程序中输出数据，且数据的单位为字符
    （16 bit）

    Writer的基本方法
    //向输出流中写入一个字符数据，该字节数据为参数b的低16位
    void write(int c) throws IOException

    //将一个字符类型的数组中的数据写入输出流
    void wirte(char[] cbuf) throws IOExcepiton

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

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

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

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

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

  常见的节点流和处理流

 

 
  文件流
    访问文件
    FileInputStream和FileOutputStream分别继承自InputStream和OutputStream
    用于向文件中输入和输出字节
    FileInputStream和FileOutputStream的常用构造方法：
    FileInputStream(String name) throws FileNotFoundException
    FileInputStream(File file)   throws FileNotFoundException
    FileOutputStream(String name) throws FileNotFoundException
    FileOutputStream(File file)   throws FileNotFoundException
    FileOutputStream(File file, boolean append)
                     throws FileNotFoundException

    FileInputStream和FileOutputStream类支持其父类InputStream和OutputStream
    所提供的数据读写方法

    注意：
    1）在实例化FileInputStream和FileOutputStream流时要用try-catch语句以处理其可能
    抛出的FileNotFoundException
    2）在读写数据时也要用try-catch语句以处理可能抛出的IOException
    3）FileNotFoundException是IOException的子类

    FileReader和FileWriter是按字符读写文件

/*打印unicode字符集*/

import java.io.*;
class TestFileWriter {
public static void main(String args[]) {
  FileWriter fw = null;
  try {
    fw = new FileWriter("d:\\test\\unicode.txt");
    for (int c=0; c <= 50000; c++) {
      fw.write(c);
    }
    fw.close();
    }
    catch (IOException ex) {
      ex.printStackTrace();
      System.out.println("文件写入错误");
      System.exit(-1);
    }
  }
}

  缓冲流
    缓冲流要"套接"在相应的节点流之上，对读写的数据提供了缓冲的功能，
    提高了读写的效率，同时增加了一些新的方法
    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 sz)

    缓冲输入流支持其父类的mark和reset方法
    BufferedReader提供了readLine()方法用于读取一行字符串（以\r或\n分隔）
    BufferedWriter提供了newLine()方法用于写入一个行分隔符
    对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存
    中的数据立刻写出

  转换流
    InputStreamReader和OutputStreamWriter用于字节数据到字符数据
    之间的转换，原来是一个字节一个字节读，套上之后变成一个字符
    一个字符的读
    InputStreamReader需要和InputStream“套接”，把InputStream转换
    成Reader，字节流转换成字符流
    OutputStreamWriter需要和OutputStream“套接”，把OutputStream转换
    成Writer，转换成Writer后可以写一个字符串进去

    转换流在构造时可以指定其编码集合，例如：
    InputStream isr = InputStreamReader(System.in, "ISO8859_1");
    //ISO8859_1包含了所有的西欧语言，latin-1（拉丁1）

    System.in（返回InputStream）套上InputStreamReader，读字符且支持汉字，外面再套上BufferedReader
    可以用readLine方法，读一行
    System.in同步方法，你不输入，我就不能干别的，程序就停在这行

    没有把字符转换成字节的，不需要

  数据流
    一个long类型的数占4个字节
    如果要把一个long类型写到文件里可以转换成String，但是太浪费空间
    数据流可以直接把这8个字节写到文件里
    DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，
    它属于处理流，需要分别“套接”在InputStream和OutputStream类型的节点上

    DataInputStream和DataOutputStream提供了可以存取与机器无关的Java
    原始类型数据（如：int, double等）的方法，还可以写UTF8的字符串
    DataInputStream和DataOutputStream的构造方法：
    DataInputStream(InputStream in)
    DataOutputStream(OutputStream out)

  Print流
    打印流，只有输出流没有输入流
    PrintWriter和PrintStream都属于输出流，分别对应字符和字节
    PrintWriter和PrintStream提供了重载的print
    Println方法用于多种数据类型的输出
    PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态
    获取错误信息
    PrintWriter和PrintStream有自动flush功能

    System.out.print和System.out.println就是用Print流
    System.out就是PrintStream类型

    PrintWriter(Writer out)
    PrintWriter(Writer out, boolean autoFlush)
    PrintWriter(OutputStream out)
    PrintWriter(OutputStream out, boolean autoFlush)
    PrintStream(OutputStream out)
    PrintStream(OutputStream out, boolean autoFlush)

    Log4j Java的日志开发包

  Object流
    直接将Object写入或读出 --序列化 把一个Object直接的转换成字节流写到
    硬盘上或写到网络上
    ObjectOutputStream 专门用来写Object的
    ObjectInputStream 将读入的内容分解成一个Object

    transient关键字
      transient透明的
      transient int k = 15;
      transient修饰的成员变量在序列化的时候不予考虑

    Serializable接口
      标记性的接口，它没有定义任何方法，给编译器看，编译器看到后就知道
      这个类可以被序列化

    Externalizable接口
      外部化
      自己控制序列化过程

  小结
    //最基础的4个抽象类
    InputStream/OutputStream
    Reader/Writer

    //对文件的读写
    FileInputStream/FileOutputStream
    FileReader/FileWriter

    //带小桶的，带缓冲区的
    BufferedInputStream/BufferedOutputStream
    BufferedReader/BufferedWriter

    //对一个内存里面字节数组进行读写
    ByteaArrayInputStream/ByteAttayOutputStream

    //转换流，把字节转成字符
    InputStreamReader/OutputStreamWriter

    //直接写基础数据类型，还能写unicode字符串
    DataInputStream/DataOutputStream

    //打印流
      PrintStream/PrintWriter

    //需要掌握关键字transient，Serializable接口
    ObjectInputStream/ObjectOutputStream