24.Java中的字符流

Writer

1.子类OutputStreamWriter。

OutputStreamWriter的构造方法：
创建使用默认字符集的 OutputStreamWriter. (包装了一个底层字节流)
public OutputStreamWriter(OutputStream out)
 
创建使用给定字符集的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out, String charsetName)
 
Writer写字符数据的write方法：
写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。
public void write(int c)
 
向流中，写入整个字符数组
public void write(char[] cbuf)
 
向流中写入，从cbuf字符数组的第offset个位置开始的，Len个字符
public void write(char[] cbuf,int off,int len)
 
向流中写入一个字符串
public void write(String str)
 
向流中写入一个字符串的一部分
public void write(String str,int off,int len)
 
和字节流不同，字符流都有缓冲区(该缓冲区主要是在编解码的时候来使用的)

public class Demo1 {

  public static void main(String[] args) throws IOException {

    // 构造方法
    constructor();

    // write方法
    FileOutputStream fos = new FileOutputStream("b.txt");
    // public OutputStreamWriter(OutputStream out)
    Writer writer = new OutputStreamWriter(fos);

    String data = "你好";
    char[] chars = data.toCharArray();

    //public void write(int c)
    for (int i = 0; i < chars.length; i++) {
      writer.write(chars[i]);
    }


    // 向流中，写入整个字符数组
    //public void write(char[] cbuf)
    writer.write(chars);

    // 向流中写入，从cbuf字符数组的第offset个位置开始的，Len个字符
    //public void write(char[] cbuf,int off,int len)
    writer.write(chars, 1, 1);


    // 向流中写入一个字符串
    //public void write(String str)
    writer.write(data);

    //3. 关闭流，释放资源


    // 向流中写入一个字符串的一部分
    //public void write(String str,int off,int len)
    writer.write(data, 1, 1);

    writer.close();




  }

  private static void constructor() throws FileNotFoundException, UnsupportedEncodingException {
    // 创建OutputStreamWriter对象
    FileOutputStream fos = new FileOutputStream("b.txt");
    // public OutputStreamWriter(OutputStream out)
    Writer writer = new OutputStreamWriter(fos);

    FileOutputStream fileOutput = new FileOutputStream("c.txt");
    // public OutputStreamWriter(OutputStream out, String charsetName)
    Writer outputWriter = new OutputStreamWriter(fileOutput, "gbk");
  }

}

2.子类FileWriter
用来写入字符文件的便捷类
public FileWriter(String fileName)
public FileWriter(String fileName, boolean append)

3. 子类BufferedWriter：
构造方法：
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流，包装一个字符流。
void newLine()
（向流中）写入一个行分隔符。
 

Reader

1.子类 InputStreamReader。

InputStreamReader的构造方法：
创建一个使用默认字符集的 InputStreamReader,包装一个底层字节流
public InputStreamReader(InputStream in)
 
创建使用指定字符集的 InputStreamReader。
public InputStreamReader(InputStream in,String charsetName)
 
read()方法
public int read()
读取单个字符
返回：
a. 作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)
b. 如果已到达流的末尾，则返回 -1
 
public int read(char[] cbuf)
从流中最多一次读取 一个字符数组的字符数据，填充到字符数组中
返回值：
a.读取的字符个数
b.如果已到达流的末尾，则返回 -1
 
public int read(char[] cbuf，int off ,int len)
从流中最多一次多个字符，读取到的字符从字符数组的off开始填充，最多填充len个字符
返回值：
a.读取的字符个数
b.如果已到达流的末尾，则返回 -1

public static void main(String[] args) throws IOException {
    // 创建InputStreamReader对象
    constructor();

    // 测试字符输入流Reader的read方法
    FileInputStream fis = new FileInputStream("b.txt");
    // public InputStreamReader(InputStream in)
    Reader reader = new InputStreamReader(fis);

    //public int read()
    int readChar;
    while ((readChar = reader.read()) != -1) {
      char c = (char) readChar;
      System.out.println(c);
    }

    //public int read(char[] cbuf)
    // 在实际开发中，一般是1024的整数倍
    char[] cbuf = new char[1024];

    int len = reader.read(cbuf);
    String s = new String(cbuf, 0, len);
    System.out.println(s);

    //关闭流并释放资源
    reader.close();


  }

  private static void constructor() throws FileNotFoundException, UnsupportedEncodingException {
    // 构造方法

    FileInputStream fis = new FileInputStream("b.txt");
    // public InputStreamReader(InputStream in)
    Reader reader = new InputStreamReader(fis);

    FileInputStream fileInput = new FileInputStream("b.txt");
    //public InputStreamReader(InputStream in,String charsetName)
    Reader inputReader = new InputStreamReader(fileInput, "utf-8");
  }

}

2.子类FileReader
用来读取字符文件的便捷类。
public FileReader(String fileName)
public FileReader(File file)

public class Demo1 {

  public static void main(String[] args) throws IOException {

    // 测试构造方法
    //constructor();

    Reader reader = new FileReader("b.txt");
    Writer writer = new FileWriter("copy.txt");

    char[] cbuf = new char[1024];
    int len;
    while ((len = reader.read(cbuf)) != -1) {
      writer.write(cbuf, 0, len);
    }

    reader.close();
    writer.close();

  }

  private static void constructor() throws IOException {
    // public FileWriter(String fileName)
    // 如果在创建FileWriter对象的时候文件存在，会默认清空文件内容
//    FileWriter fileWriter = new FileWriter("a.txt");

    //public FileWriter(String fileName, boolean append)
    FileWriter fileWriter = new FileWriter("a.txt", true);
    fileWriter.write("你好王五");

    fileWriter.close();
  }

}

3.子类BufferedReader
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流，包装一个字符输出流。
String readLine()
a. 读取一个文本行
b. 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null

public class Demo1 {

  public static void main(String[] args) throws IOException {
    // 创建 BufferedReader
    BufferedReader br = new BufferedReader(
        new InputStreamReader(new FileInputStream("b.txt")));

    // 创建 BufferedWriter
    BufferedWriter bw = new BufferedWriter(
        new OutputStreamWriter(new FileOutputStream("my.txt")));

    //按行复制文本数据
    String s;
    while ((s = br.readLine()) != null) {
      // 将读取到的一行文本数据写入缓冲字符输出流(并不包含换行符)
      bw.write(s);
      // 在一行文本之后，添加行分隔符
      bw.newLine();
    }


    // 关闭流并释放资源(关闭最上层的包装流即可)
    br.close();
    bw.close();


  }

}