Java学习第十六天——字符流读写文件、字符缓冲流拷贝文件

字符流读写文件

字符流读数据—按单个字符读取

创建字符流读文件对象：

​ Reader reader = new FileReader(“readme.txt”);

调用方法读取数据：

​ int data = reader.read();

只读取一个字符，返回该字符代表的整数（ASCII码），若到达流的末尾，返回-1；

异常处理(两种异常处理方式都可用)：

throws IOException

关闭资源：

reader.close();

需要自己另外创建相关的文件夹即文件

package io.demo;

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

public class ReaderDemo1 {
//    FileNotFoundException是属于IOException的子类，所以FileNotFoundException可以不写
    public static void main(String[] args) throws IOException {
//        通过字符流读取数据
//        1.创建字符输入流对象
        Reader reader = new FileReader("lib/1.txt");            //会报错，所以在main函数后面加上throws FileNotFoundException；lib文件夹下的1.txt文件
//        2.读取数据
//        int read = reader.read();           //第一次读取a，97
//        System.out.println("read:"+read);
//        int read1 = reader.read();          //第二次读取b，98
//        System.out.println("read:"+read1);
//        int read2 = reader.read();            //第三次读取C，99
//        System.out.println("read:"+read2);
//        int read3 = reader.read();          //第四次读取d，以此类推，100
//        System.out.println("read:"+read3);
//        int read4 = reader.read();
//        System.out.println("read:"+read4);      //已经到达流的末尾，所以返回-1
        /*
            优化上述的代码：用循环改进
            又因为不知道循环的次数，所以用while循环
         */
        int ch;             //定义变量，用来接收读取到的字符
/*        (ch = reader.read()) != -1:做了三件事
                    1.执行reader.read(),取文件中读取一个字符；
                    2.执行ch = reader.read()，将读取到的字符赋值给变量ch
                    3.最后执行(ch = reader.read()) != -1，用读取到的字符（内容）和-1进行比较
  */
        while ((ch = reader.read()) != -1) {
//            ch = reader.read();
            System.out.println("read:"+ch);
        }
//        3.释放资源
        reader.close();     //报错，在main函数加上IOException
    }
}

字符流读数据—按字符数组读取

创建字符流读文件对象：

​ Reader reader = new FileReader(“readme.txt”);

调用方法读取数据：

​ char[] chs = new char[4];

​ int len = reader.read(chs);

一次读一个字符数组，将读取到的内容存到数组中，并返回读取到的有效字符数，若读不到返回-1

异常处理：

throws IOException

关闭资源：

reader.close();

package io.demo;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
//        需求：通过字符流读取数据，一次读取一个字符数组
//        1.创建字符输入流对象
        Reader reader = new FileReader("lib/1.txt");        //abcdefg
//        2.读取数据
//        char[] chs = new char[3];       //读取长度为4的字符，字符数组会拼接成字符串
//        int len = reader.read(chs);
//        System.out.println(chs);        //abc
//        System.out.println(len);        //3
//
//        int len2 = reader.read(chs);
//        System.out.println(chs);        //def：覆盖了abc
//        System.out.println(len2);           //3
//
//        int len3 = reader.read(chs);
//        System.out.println(chs);        //gef：只有g覆盖了d，没有其余的有效字符覆盖另外两个字符
//        System.out.println(len3);           //1,只有g是有效的
//
//        int len4 = reader.read(chs);
//        System.out.println(chs);        //gef：没有新的有效字符可以覆盖
//        System.out.println(len4);       //-1：因为没有读取到有效的字符，就返回-1


//        简化做法：用while循环改进
//        定义字符数组
        char[] ch = new char[3];        //ch存的是具体的字符数组
//        定义一个变量，记录读取到的有效字符数
        int len;        //有效字符数
        while ((len = reader.read(ch) )!= -1) {
//            将读取到的内容，转成字符串，然后打印
            /*
                ch:表示要操作的数组
                0：表示起始的索引
                len：表示要操作的字符的个数
             */
            String s = new String(ch,0,len);        //数组：[g,e,f],起始位置为0,个数len为1，则输出g
            System.out.println(s);
        }
//        3.释放数据
        reader.close();
    }
}

字符流写数据—按单个字符写入

创建字符流写文件对象：

​ Writer writer = new FileWriter(“1.txt”);

调用方法写入数据：

​ int x = “我”;

​ writer.write(x);

写入一个数据

异常处理

​ throws IOException

关闭资源：

​ writer.close();

字符流写数据—按字符数组写入

创建字符流写文件对象：

​ Writer writer = new FileWriter(“1.txt”);

调用方法写入数据：

​ char[] chs = {‘我’,‘爱’,‘学’,‘习’} ;

异常处理

​ throws IOException

关闭资源：

​ writer.close();

字符流写数据—按字符串写入

创建字符流写文件对象：

​ Writer writer = new FileWriter(“1.txt”);

调用方法写入数据：

​ writer.write(“我爱学习”);

写一个字符串

异常处理

​ throws IOException

关闭资源：

​ writer.close();

package io.demo;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/*
    字符流写数据
    Writer类中的方法
            void write(int ch);     一次写一个字符
            void write(char[] ch,int index,int len);        一次写一个指定的字符数组
            void write(String);         一次写一个字符串
 */
public class WriterDemo {
    public static void main(String[] args) throws IOException {
//需求：通过字符流，写数据
//        1.创建一个字符输出流对象
        Writer writer = new FileWriter("lib/1.txt");
//        2.写数据
//        一次写入一个字符
//        writer.write('好');          //在1.txt中就会写入好
//一次写一个指定的字符数组
//        char[] ch = {'我','爱','学','习'};          //字符数组，记得用单引号
//        writer.write(ch);
//        writer.write(ch,2,2);       //从ch字符数组的索引位置为2（索引是从0开始的），长度为2的地方写入数据：学习
//
//一次写入一个字符串
        writer.write("钟云耀同学要好好学习，天天向上");
//        3.释放资源
        writer.close();
    }
}

字符流拷贝文件—按单个字符读写

拷贝文件：Reader和Writer合作完成

创建字符流读文件对象

​ Reader reader = new FileReader(“readme.txt”);

创建字符流写文件对象

​ Writer writer = new FileWriter(“1.txt”);

调用方法读取数据：

​ int data = reader.read();

调用方法写入数据：

​ writer.write(data);

异常处理：

​ throws IOException

关闭资源：

​ reader.close();

​ writer.close();

IO流拷贝文件核心6步：
    1.创建字符输入流对象，关联数据源文件
    2.创建字符输出流随心，关联目的地文件
    3.定义变量，记录读取到的内容
    4.循环读取，只要条件满足就一直读取，并将读取到的内容赋值给变量
    5.将读取到的数据写入到目的地文件中
    6.释放资源

package io.demo;

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

public class CopyFile {
    public static void main(String[] args) throws IOException {
//        需求：通过字符流拷贝文件，一次读写一个文件
//        例如：将1.txt文件中的内容复制到2.txt文件中
        /*
        注释就是思路，思路就是注释
            IO流拷贝文件核心6步：
                1.创建字符输入流对象，关联数据源文件
                2.创建字符输出流随心，关联目的地文件
                3.定义变量，记录读取到的内容
                4.循环读取，只要条件满足就一直读取，并将读取到的内容赋值给变量
                5.将读取到的数据写入到目的地文件中
                6.释放资源
         */
//        1.创建字符输入流对象，关联数据源文件
//        2.创建字符输出流随心，关联目的地文件
//       优化
//       Reader reader = new FileReader("lib/1.txt");
//       Writer writer = new FileWriter("lib/2.txt");
        FileReader fr = new FileReader("lib/1.txt");
        FileWriter fw = new FileWriter("lib/2.txt");
//        如果目的地文件不存在，程序会自动创建
//        3.定义变量
        int len;
//        4.循环读取
        while ((len = fr.read()) != -1) {
//            5.
            fw.write(len);
        }
//        6.释放资源
        fr.close();
        fw.close();
    }
}

字符流拷贝文件—按字符数组读写

创建字符流读文件对象

​ Reader reader = new FileReader(“readme.txt”);

创建字符流写文件对象

​ Writer writer = new FileWriter(“1.txt”);

调用方法读取数据：

​ char[] ch = new char[4];

​ int len = reader.read(ch);

调用方法写入数据：

​ writer.wtite(ch,0,len);

异常处理：

​ throws IOException

关闭资源：

​ reader.close();

​ writer.close();

package io.demo;

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

public class CopyFile2 {
    public static void main(String[] args) throws IOException {
//        需求：通过字符流拷贝文件，一次读写一个文件
//        例如：将1.txt文件中的内容复制到2.txt文件中
        /*
            IO流拷贝文件核心6步：
                1.创建字符输入流对象，关联数据源文件
                2.创建字符输出流随心，关联目的地文件
                3.定义变量，记录读取到的有效字符数内
                4.通过循环读取，只要条件满足就一直读取，并将读取到的内容赋值给变量
                5.将读取到的数据写入到目的地文件中
                6.释放资源
         */
//        1.
        FileReader reader =new FileReader("lib/1.txt");
//        2.
        FileWriter writer = new FileWriter("lib/2.txt");
//        3.
//        定义一个字符数组
        char[] ch = new char[1024];     //最好的1024的整数倍
//        用来记录读取到的有效字符数
        int len;
//        4.
        while ((len = reader.read(ch)) != -1) {
//            5.
            writer.write(ch,0,len);
        }
//        6.
        reader.close();
        writer.close();
    }
}

字符缓冲流

BufferedReader:字符缓冲输入流（高效字符输入流）

构造方法：

​ public BufferedReader(Reader reader);

成员方法：

​ public String readLine();

一次读取一行数据并返回读取的到的数据内容，读不到则返回null

BufferedWriter:字符缓冲输出流（高效字符输出流）

构造方法：

​ public BufferedWriter(Writer writer);

成员方法：

​ public void newLine();

根据当前操作系统给出对应的换行符。

windows操作系统：\r\n；
mac操作系统:\r;
unix操作系统:\n

**特点：**字符缓冲流自带有缓冲区，大小为8192个字符，就是16kb

字符缓冲流拷贝文件的标准代码

创建字符流读文件对象：

​ BufferedReader br = new BufferedReader(new FileReader(“1.txt”));

创建字符流写文件对象：

​ BufferedWriter bw = new BufferedWriter(new FileWriter(“2.txt”));

异常处理：

​ throws IOException

使用while循环读写数据：

​ int len;

​ while ((len = br.read()) != -1) {

​ bw.write(len);

​ }

关闭资源:

​ br.close();

​ bw.close();

package io.demo;

import java.io.*;

public class BufferedDemo {
    public static void main(String[] args) throws IOException {
//        需求：通过字符缓冲流，将1.txt文件中的内容拷贝到2.txt文件中
//        1.创建缓冲输入流对象，关联数据源文件
//        1.1创建普通的字符输入流对象
        FileReader fr = new FileReader("lib/1.txt");
//        1.2创建缓冲输入流对象
        BufferedReader bfr = new BufferedReader(fr);
//        简化1.1和1.2的代码
//        BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
//        2.创建缓冲输出流对象，关联目的地文件
//        2.1创建字符输出流对象
        FileWriter fw = new FileWriter("lib/2.txt");
//        2.2
        BufferedWriter bfw = new BufferedWriter(fw);
//        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
//        3.定义变量，记录读取到的数据
        int len;
//        4.循环读取，只要条件满足就一直读取，并将读取到的数据赋值给变量
        while ((len = bfr.read()) != -1) {      //底层是按照字符数组读写的，而不是一个一个字符读写的
            bfw.write(len);
        }
//        5.将读取到的数据写入到目的地文件中
//        6.释放资源
        bfr.close();
        bfw.close();
    }
}

package io.demo;

import java.io.*;
//注意:字符流只能拷贝纯文本文件，
public class BufferedDemo2 {
    public static void main(String[] args) throws IOException {
//        需求：通过字符缓冲流一次读写一行的方式，将1.txt文件中的内容拷贝到2.txt文件中
//        1.创建字符缓冲流输入对象
//        分开写
//        FileReader reader = new FileReader("lib/1.txt");
//        BufferedReader br = new BufferedReader(reader);
//        合并
        BufferedReader br = new BufferedReader(new FileReader("lib/1.txt"));
//        2.创建字符缓冲输出流对象
//        FileWriter writer = new FileWriter("lib/2.txt");
//        BufferedWriter bw = new BufferedWriter(writer);
        BufferedWriter bw = new BufferedWriter(new FileWriter("lib/2.txt"));
//        3.定义变量，记录读取到的数据内容
        String s;
//        4.循环读取，并将读取到的数据内容赋值给变量
        while ((s = br.readLine()) != null) {        //读不到数据，则返回null
//        5.将读取到的数据写入目的地文件中
            bw.write(s);
//            注意一个容易忽略的小细节:不要忘记换行；
//            windows操作系统：\r\n；
//            mac操作系统:\r;
//            unix操作系统:\n
            bw.newLine();
        }

//        6.释放资源
        br.close();
        bw.close();
    }
}