Day 16：输入输出字符流、缓冲输入字符流

输入输出字节流输出字符时的常见问题

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class Demo1 {

    public static void main(String[] args) throws IOException {
        //writeTest();
        readrTest();
    }
    //使用字节流读取中文
    public static void readrTest() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //读取内容
        //int content = 0;

        /*while((content = fileInputStream.read())!=-1){
         //出现乱码的原因： 一个中文在gbk码表中默认是占两个字节，
          // 目前你只读取了一个字节而已，所以不是一个完整的中文。
            System.out.print((char)content);
        }*/

        byte[] buf = new byte[2];
        for(int i = 0 ; i < 3 ; i++){
            fileInputStream.read(buf);
            System.out.print(new String(buf));
        }
        //关闭资源
        fileInputStream.close();

    }
    //使用字节流写中文。   字节流之所以能够写中文是因为借助了字符串的getBytes方法对字符串进行了编码（字符---->数字）。
    public static void writeTest() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输出通道
        FileOutputStream fileOutputStream  = new FileOutputStream(file);
        //准备数据，把数据写出。
        String data = "大家好";
        byte[] buf = data.getBytes();    //把字符串转换成字节数组
        System.out.println("输出的内容："+ Arrays.toString(buf));
        fileOutputStream.write(buf);
        ///关闭资源
        fileOutputStream.close();
    }
}

当字母和中文汉字混合又如何处理呢？

字节流：字节流读取的是文件中的二进制数据，读到的数据并不会帮你转换成你看得懂的字符。 
字符流： 字符流会把读取到的二进制的数据进行对应 的编码与解码工作。   字符流 = 字节流 + 编码(解码)
 
输入字符流：
　　Reader 输入字符流的基类   抽象类
　　　　FileReader 读取文件的输入字符流。

FileReader的用法：
 1. 找到目标文件
 2. 建立数据的输入通道
 3. 读取数据
 4. 关闭资源

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\jee-Workspaces\\Day16\\src\\Demo1.java");
        FileReader fr = new FileReader(file);
        int content = 0;
        while((content = fr.read())!=-1) {
            System.out.print((char)content);
        }
        fr.close();
    }
}

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo2 {

    public static void main(String[] args) throws IOException {
        //找到目标文件
        File file = new File("E:\\\\jee-Workspaces\\\\Day16\\\\src\\\\Demo1.java");
        // 建立数据的输入通道
        FileReader fileReader = new FileReader(file);
        //建立缓冲字符数组读取文件数据
        char[] buf = new char[1024];
        int length = 0 ;
        while((length = fileReader.read(buf))!=-1){
            System.out.print(new String(buf,0,length));
        }
    }
}

输出字符流:

　　Writer 输出字符流的基类。 抽象类
　　　　FileWriter 向文件数据数据的输出字符流

FileWriter的使用步骤：
 1. 找到目标文件。
 2. 建立数据输出通道
 3. 写出数据。
 4. 关闭资源
 
FileWriter要注意的事项：
 　　1. 使用FileWriter写数据的时候，FileWriter内部是维护了一个1024个字符数组的，写数据的时候会先写入到它内部维护的字符数组中，如果需要
 　　　把数据真正写到硬盘上，需要调用flush或者是close方法或者是填满了内部的字符数组。
 　　2. 使用FileWriter的时候，如果目标文件不存在，那么会自动创建目标文件。
 　　3.使用FileWriter的时候， 如果目标文件已经存在了，那么默认情况会先情况文件中的数据，然后再写入数据 ， 如果需要在原来的基础上追加数据，
  　　  需要使用“new FileWriter(File , boolean)”的构造方法，第二参数为true。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3 {

    public static void main(String[] args) throws IOException {
        File file = new File("F:\\a.txt");
        FileWriter fw = new FileWriter(file);
        //FileWriter fw = new FileWriter(file,true);使用FileWriter的时候， 如果目标文件已经存在了，那么默认情况会先情况文件中的数据，然后再写入数据 ， 如果需要在原来的基础上追加数据，需要使用“new FileWriter(File , boolean)”的构造方法，第二参数为true。
        String data = "你好";
        fw.write(data);//字符流具备解码功能
        fw.flush();
        fw.close();
    }
}

何时使用字符流，何时使用字节流？依据是什么？

　　使用字符流的应用场景： 如果是读写字符数据的时候则使用字符流。

　　使用字节流的应用场景： 如果读写的数据都不需要转换成字符的时候，则使用字节流。

比如说图片拷贝就要字节流，他不需要转换成字符。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo3 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader("F:\\a.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("F:\\b.exe"));
        String line=null;
        while((line = bufferedReader.readLine())!=null){
        bufferedWriter.write(line);
        }
        bufferedWriter.close();
        bufferedReader.close();
    }
}

缓冲输入字符流:
　　Reader 所有输入字符流的基类。 抽象类
　　　　FileReader 读取文件字符串的输入字符流。
　　　　BufferedReader   缓冲输入字符流  。 缓冲 输入字符流出现的目的是为了提高读取文件 的效率和拓展了FileReader的功能。  其实该类内部也是维护了一个字符数组

记住：缓冲流都不具备读写文件的能力。

BufferedReader的使用步骤：
 1.找到目标文件
 2 .建立数据的输入通道。

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;

public class Demo4 {

    public static void main(String[] args) throws IOException {
//         readTest1();
        File file  = new File("F:a.txt");
        //建立数据的输入通道。
        FileReader fileReader = new FileReader(file);
        String line =  null;

        while((line = myReadLine(fileReader))!=null){
            System.out.println(line);
        }
    }

    //自己去实现readLine方法。
    public static String myReadLine(FileReader fileReader) throws IOException{
        //创建一个字符串缓冲类对象
        StringBuilder sb = new StringBuilder();  //StringBuilder主要是用于存储读取到的数据
        int content = 0 ;
        while((content = fileReader.read())!=-1){
            if(content=='\r'){
                continue;
            }else if(content=='\n'){
                break;
            }else{
                //普通字符
                sb.append((char)content);
            }
        }
        //代表已经读取完毕了。
        if(content ==-1){
            return null;
        }
        return sb.toString();
    }

    public static void readTest1() throws IOException{
        //找到目标文件
        File file  = new File("F:\\a.txt");
        //建立数据的输入通道。
        FileReader fileReader = new FileReader(file);
        //建立缓冲输入字符流
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        //读取数据
        /*int content = bufferedReader.read();  //读到了一个字符。 读取到的字符肯定也是从Bufferedreader内部的字符数组中获取的到。所以效率高。
        System.out.println((char)content);*/
        //使用BUfferedReader拓展的功能，readLine()  一次读取一行文本，如果读到了文件的末尾返回null表示。
        String line =  null;
        while((line = bufferedReader.readLine())!=null){ // 虽然readLine每次读取一行数据，但是但会的line是不包含\r\n的、
            System.out.println(Arrays.toString("aaa".getBytes()));
        }
        //关闭资源
        bufferedReader.close();
    }
}