IO---2

IO_2

IO流概述和分类

    1 IO流用来处理设备之间的数据传输

    2 IO流的分类：
            流向：
                    输入流 读取数据
                    输出流 写出数据
            数据类型：
                    字节流
                        字节输入流   读取数据    InputStream
                        字节输出流   写出数据    OutputStream
                    字符流
                        字符输入流   读取数据    Reader
                        字符输出流   写出数据    Writer

                注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说， 
                    默认情况下是按照数据类型来分的。

字节流

    FileOutputStream的构造方法：
                FileOutputStream(File file) 
                FileOutputStream(String name)

    字节输出流操作步骤：
                A:创建字节输出流对象
                B:写数据
                C:释放资源

字节输出流操作步骤：

  A:创建字节输出流对象
  B:调用write()方法
  C:释放资源

  public void write(int b):写一个字节
  public void write(byte[] b):写一个字节数组
  public void write(byte[] b,int off,int len):写一个字节数组的一部分

字节输入流操作步骤：

  A:创建字节输入流对象
  B:调用read()方法读取数据，并把数据显示在控制台
  C:释放资源

  读取数据的方式：
      A:int read():一次读取一个字节
      B:int read(byte[] b):一次读取一个字节数组
             一次读取一个字节数组：int read(byte[] b)
              返回值其实是实际读取的字节个数。

  这种类被称为：缓冲区类(高效类)
  写数据：BufferedOutputStream
  读数据：BufferedInputStream

基本字节流一次读写一个字节

public static void method1(String srcString, String destString)
        throws IOException {
    FileInputStream fis = new FileInputStream(srcString);
    FileOutputStream fos = new FileOutputStream(destString);

    int by = 0;
    while ((by = fis.read()) != -1) {
        fos.write(by);
    }

    fos.close();
    fis.close();
}

基本字节流一次读写一个字节数组

public static void method2(String srcString, String destString)
        throws IOException {
    FileInputStream fis = new FileInputStream(srcString);
    FileOutputStream fos = new FileOutputStream(destString);

    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = fis.read(bys)) != -1) {
        fos.write(bys, 0, len);
    }

    fos.close();
    fis.close();
}

高效字节流一次读写一个字节：

public static void method3(String srcString, String destString)
        throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
            srcString));
    BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(destString));

    int by = 0;
    while ((by = bis.read()) != -1) {
        bos.write(by);

    }

    bos.close();
    bis.close();
}

高效字节流一次读写一个字节数组：

public static void method4(String srcString, String destString)
        throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
            srcString));
    BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(destString));

    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
        bos.write(bys, 0, len);
    }

    bos.close();
    bis.close();
}

字符流

字符流概述

 字符流    =   字节流 +   编码表

            编码
                把看得懂的变成看不懂的
            解码
                把看不懂的变成看得懂的

String类中的编码和解码的问题

      String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
      byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组

      编码:把看得懂的变成看不懂的
      String -- byte[]

      解码:把看不懂的变成看得懂的
      byte[] -- String


  OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
  OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字
                                                      节流数据转换为字符流


  InputStreamReader(InputStream is):用默认的编码读取数据
  InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据

OutputStreamWriter的方法：

  public void write(int c):写一个字符
  public void write(char[] cbuf):写一个字符数组
  public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
  public void write(String str):写一个字符串
  public void write(String str,int off,int len):写一个字符串的一部分

InputStreamReader的方法：

  int read():一次读取一个字符
  int read(char[] chs):一次读取一个字符数组

字符流的缓冲流

      字符流为了高效读写，也提供了对应的字符缓冲流。
      BufferedWriter:字符缓冲输出流
      BufferedReader:字符缓冲输入流

字符缓冲流的特殊方法：

      BufferedWriter:
            public void newLine():根据系统来决定换行符
      BufferedReader:
            public String readLine()：一次读取一行数据
            包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

字符流读写文本文件的5种方式

基本字符流一次读写一个字符

private static void method1(String srcString, String destString)
        throws IOException {
    FileReader fr = new FileReader(srcString);
    FileWriter fw = new FileWriter(destString);

    int ch = 0;
    while ((ch = fr.read()) != -1) {
        fw.write(ch);
    }

    fw.close();
    fr.close();
}

}

基本字符流一次读写一个字符数组

private static void method2(String srcString, String destString)
        throws IOException {
    FileReader fr = new FileReader(srcString);
    FileWriter fw = new FileWriter(destString);

    char[] chs = new char[1024];
    int len = 0;
    while ((len = fr.read(chs)) != -1) {
        fw.write(chs, 0, len);
    }

    fw.close();
    fr.close();
}

字符缓冲流一次读写一个字符

private static void method3(String srcString, String destString)
        throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

    int ch = 0;
    while ((ch = br.read()) != -1) {
        bw.write(ch);
    }

    bw.close();
    br.close();
}

字符缓冲流一次读写一个字符

private static void method3(String srcString, String destString)
        throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

    int ch = 0;
    while ((ch = br.read()) != -1) {
        bw.write(ch);
    }

    bw.close();
    br.close();
}

字符缓冲流一次读写一个字符数组

private static void method4(String srcString, String destString)
        throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

    char[] chs = new char[1024];
    int len = 0;
    while ((len = br.read(chs)) != -1) {
        bw.write(chs, 0, len);
    }

    bw.close();
    br.close();
}

字符缓冲流一次读写一个字符串

private static void method5(String srcString, String destString)
        throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(srcString));
    BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

    String line = null;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    bw.close();
    br.close();
}