Java I/O 技术(三)—— 操作 字符流 的对象

时间:2023-02-17 17:56:39

字符流的抽象基类是:Writer 和 Reader !

用于操作字符流的子类对象有:

1. FileReader  和 FileWriter .

        2. 功能对象:BufferedReader  和 BufferedWriter  他们分别对应于:FileReader 和 FileWriter ,用来达到对FileReader  和 FileWriter 的高效操作,具体见下文讲解。

——————————————————————————————————————————

【FileWriter】的学习,将从如下5点展开,并通过具体示例来体现:

1.      基本方法的演示

2.      对象创建的细节。

3.       对象操作的细节:close()  write()  flush()

4.      续写换行

5.      文件处理是的——异常处理规范!

示例一:将一个段文字数据写入到硬盘上.

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

public class FileWriterDemo {
public static void main(String[] args) throws IOException {
/*
//需求:将一个段文字数据写入到硬盘上.
思路:
1,一段文字就是字符串数据。
2,写到硬盘上,从哪到哪呢?字符串数据在内存中,写到硬盘上——将内存中的数据搞到硬盘上,
这就涉及到了设备之间的数据处理。就要用到IO技术。
既然是从内存到硬盘,应该是输出流。
3,对于文字而言,io中提供了便捷的操作,比如字符流。
4,结合两者,需要输出流,需要字符流,可以使用字符输出流。Writer
5,具体用哪个子类对象呢?硬盘上用于存储数据的体现:文件。在这个体系中有对象FileWriter 。
*/


//1,通过FileWriter创建流对象。构造时,必须明确写入数据需要存储的位置。
/*
* 该对象一创建,目的文件就会被创建。
* 如果该文件已经存在,会被覆盖。
* 做了什么事呢?在堆内存中创建一个对象。同时调用了系统的资源。
*/
FileWriter fw = new FileWriter("demo.txt");

//2,使用字符输出流对象将字符串进行写入。调用写入方法。
//数据没有直接写入到目的文件中,而是写入到了临时缓冲中。
fw.write("abcdef");

//3,怎么把数据弄到文件中呢?发现Writer类中有一个flush()方法。刷新缓冲区,将缓冲的数据立即写入到目标中。
fw.flush();

fw.write("haha");
//4,关闭此流,关闭资源。在关闭之前,先刷一次缓冲,将数据都写入到目的中。
fw.close();

/*
* flush()和close()有什么区别?
* flush():仅将缓冲中的数据刷新到目的地。流对象可以继续使用。可以使用多次。
* close():将缓冲中的数据刷到目的地后,直接关闭流资源,流无法继续使用。只能使用一次。
* 在close()方法当中其实在关闭之前都会调用一次flush();
*
*/
}
}

通过上述示例,我们必须注意以下几点:

1.      通过FileWriter创建流对象。构造时,必须明确写入数据需要存储的位置。

2.      使用字符输出流对象将字符串写入时,必须调用 writer() 方法,但是这些字符并没有直接被写到 目的地中,而是被写在了Writer类默认的缓冲区中,这可以在Java源代码中查到。

3.      将缓冲区中的数据写到目的中,需要调用flush()方法,将缓冲区刷新。

4.      在一系列操作完成后,必须要做的动作是,关闭流,释放系统资源。需调用close()。

5.      其次就是,flush()和 close()方法调用,这两者之间的区别:上文已经提到,不在赘述。


示例二:想对刚才的文件demo.txt 进行一个续写!

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

public class FileWriterDemo2 {

private static final String LINE_SPARATOR = System.getProperty("line.separator");

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

/*
* 需求:想要来个续写。
* 这个对象创建是不行的,因为该构造一创建,就覆盖了已有的文件。
* 可以使用另一个构造函数,加入一个boolean参数,为true,就可以实现续写。
*
* 需求:想要将数据分行写入。
*
* window中的特有软件比如notepad。只识别window中的特有换行 \r\n.
* 为了在不同系统平台下换行。使用System类获取当前系统信息。
*
*
*/
//该构造方式,通过第二个参数来决定是否进行续写
FileWriter fw = new FileWriter("demo2.txt",true);
fw.write("xi"+LINE_SPARATOR+"xi");
fw.close();
}
}

上述示例主要提示我们一下几点:

1.    如果想在原来的文本后,在继续添加文字,该怎么办?这时,可以使用FileWriter的另外一个构造方法,传入加入一个boolean参数,为true,就可以实现续写。

2.    其次,就是,当数据需要分行写入时,为了让程序在不同的系统平台上都可以运行,不能讲换行的符号写死,可以动态的获取系统的属性来取到当前系统中的换行符:

privatestatic final StringLINE_SPARATOR =      System.getProperty("line.separator");

3.    无论如何都不能忘记:流不再使用的时候,必须得关闭。


在对IO系列中的FileWriter对象有了大概的了解后,我们会发现,在程序中的很多地方都会发生异常:繁多而又不同的异常。因此,我们有必要来介绍一下,Java中IO体系的异常处理规范:当然了,也是从一个示例讲起:

import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo3 {

public static void main(String[] args) {
/*
* IO异常的处理规范。
* 创建流对象—————— 在try外创建流对象的引用。 在try内对流对象进行初始化。
*/
FileWriter fw = null;
try {
fw = new FileWriter("k:\\demo3.txt");

fw.write("abcde");
fw.flush();

} catch (IOException e) {

System.out.println(e.toString());
} finally {
//在关闭之间必须得判断这个流是否存在,是否被创建。
if (fw != null)
try {
fw.close();
} catch (IOException e) {

// 相关的代码处理。比如说,将关闭失败的信息记录到日志文件中。
throw new RuntimeException("关闭失败");
}
}
}
}

通过以上示例,我们的明白,在Java中IO异常的处理时:

1.    对象的创建方式——创建流对象时, 在try外创建流对象的引用。 在try内对流对象进行初始化。

2.    在finally的代码中,流的关闭时必须得执行的动作。但是,在关闭前,必须得判断,这个流是否创建成功,如果没有创建成功的话,何谈关闭。

3.    在处理流关闭失败后,可以进行一系列的操作:或者将关闭失败的信息记录到日志文件中。


————————————————————————————

下面我们来讲解:另一个重要的对象——FileReader。

 FileReader: 这个对象的主要用途在于读取,因此,我们将着重分析,它对指定文件的读取方式,FileReader 读取字符时有两种方式:

1. 读取单个字符的方法:读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前,此方法一直阻塞。返回值:作为整数读取的字符,范围在 0 到 65535 之间 (0x00-0xffff),如果已到达流的末尾,则返回 -1

2. 读取字符数组:将读到的字符存储到字符数组里面,并且返回字符数组的长度。如果到达流的末尾,返回-1.

下面来演示,他们的具体应用:

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

public class FileReaderTest {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
FileReader fr = new FileReader("IO流.txt");

//演示读取单个字符
long time = System.currentTimeMillis();
readChar(fr);
long timereadChar = System.currentTimeMillis();

System.out.println("time Read char is = " + (timereadChar-time));
//演示读取字符到缓冲区中。

long time2 = System.currentTimeMillis();
readToBuf(fr);
long timeReadBuf = System.currentTimeMillis();
System.out.println("time Read to Buf is = " + (timeReadBuf-time2));


}
private static void readToBuf(FileReader fr) throws IOException {
//定义一个字符缓冲区,用于存放读到的字符。
char[] buf = new char[50];
//设刚开始读到的字符为0
int len = 0 ;
//一直循环读取字符到缓冲区中,直到读到流的末尾。
while((len = fr.read(buf)) != -1){
//将每次读满的缓冲区中的字符,变成字符串打印出来。
System.out.println(new String(buf , 0 , len));
}
}
private static void readChar(FileReader fr) throws IOException {
//设每个读取到的字符整数值为ch.
int ch = 0;
//循环读取字符,直到流的末尾
while((ch = fr.read()) != -1){
//将读取到的字符,强制转换为 char
System.out.print((char) ch);
}
}
}

上述两种读取方式,最明前的区别在于:

   第二种读取字符的方式,要比第一种方式高效。

到目前为止,我们已经学了FileReader, FileWrite的具体使用,以及IO异常的处理方式,下面将通过一个具体的示例,来综合的应用上述所学的知识:

我们将完成一个:文件复制的练习。并且使用两种读取字符方式来完成。该例子中用的路径,假设在你的机器中也存在。

题目:

   

        * 练习:将c盘的一个文本文件复制到d盘。

        * 思路:

        * 1,c盘的文件是一个数据的源。

        * 复制到的d盘,说明d盘是数据的存储的目的。该目的中应该有一个文件。

        * 2,先读取c盘的文件。将读取到的数据写入到目的地中。

        *3,既然是操作文本文件,只要使用字符流即可。

1.用缓冲区数组,来完成读写操作;

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

public class CopyTextTest1 {


public static void main(String[] args) {

/*
*
* 使用缓冲区数组。
* 使用的就是可以操作数组的读写方法。
*/
//1,定义字符输入流和字符输出流的引用。
FileReader fr = null;
FileWriter fw = null;

try {
//2,对流对象进行初始化。
fr = new FileReader("demo.txt");
fw = new FileWriter("copy_demo2.txt");

//3,定义一个数组缓冲区。用于缓冲读取到的数据。
char[] buf = new char[1024];

//4,读写操作。
int len = 0;
while((len = fr.read(buf))!=-1){
fw.write(buf,0,len);
}

} catch (Exception e) {
System.out.println(e.toString());
}finally{

if(fw!=null)
try {
fw.close();
} catch (IOException e) {

throw new RuntimeException("写入关闭失败");
}

if(fr!=null)
try {
fr.close();
} catch (IOException e) {

e.printStackTrace();
}
}
}
}

2. 用读取单个字符的方式来完成。

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

public class CopyTextTest {

/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {



//1,创建字符读取流对象和源相关联。
FileReader fr = new FileReader("IO流.txt");

//2,创建字符输出流对象,明确要存储数据的目的。
FileWriter fw = new FileWriter("copy_demo.txt");

//3,进行读写操作。读取一个,就写入一个。
int ch = 0;
while((ch=fr.read())!=-1){
fw.write(ch);
}
//4,关闭资源。
fw.close();
fr.close();

}

}

缓冲区高效的原因:

流对象的read():是从目的地一次读取一个;

缓冲区的read() :是通过流对象的read( [  ] ) 将一批数据读取到缓冲数组,然后再从数组中一次取一个,所以内存操作要比硬盘操作要高效。


就在刚才,我们用的高效读取方式,是将字符全部读取到数组中,来达到高效的目的,在Java中,为了提高程序的性能,为我们专门提供了对应的类:

BufferedReader  和BufferedWriter . 接下来,我们将开始学习,这两个对象。

——————————————————————————————————

【BufferedReader 】 

从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。(他的构造方法有两个,一个构造方法使用的是默认大小的缓冲区,另一个构造方法,可以设定自己的缓冲区大小)

他的牛逼之处在于,提供了一个一次读取一行的方法:

readline() ——读取一个文本行。通过下列字符之一即可认为某行已终止:换行 ('\n')、回车 ('\r')或回车后直接跟着换行。返回值:包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

下面来具体应用:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BuffereReaderDemo {

public static void main(String[] args) throws IOException {
/**
* 演示:BufferedReader
* 1. 先有字符读取流;
* 2. 该类有一个特有方法。readLine(). 一次读一行。
*/
//创建读取流对象 和 文件相关联。
FileReader fr = new FileReader("Demo.txt");

//创建读取缓冲区对象 和 流对象关联对其进行高效 操作;
BufferedReader bufr = new BufferedReader(fr);
//简写形式:
//BufferedReader bufr = new BufferedReader(new FileReader("Demo.txt"));

String line = null ;
while((line = bufr.readLine()) != null){
System.out.println(line);
}
bufr.close();
}
}

在上述示例中我们应当注意的是:

1.      BufferedReader的简写形式。

BufferedReader bufr = newBufferedReader(new FileReader("Demo.txt"));

2. 【readLine().一次读一行的原理

   从缓冲区中取出字符存储到该方法的容器中。当取出的字符是回车符时,就将已经存储的数据作为字符串返回。就是一行数据。

   ReadLine()  调用buf.read()将缓冲区中的数据存储到,自己建立的容器中。ReadLine()建立自己的容器—— StringBuilder 最合适。


下面我们来学习,BufferedWriter,作为与BufferedReader配套出现的亲兄弟,他的作用,当然显而易见。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {

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

//创建一个流对象。
FileWriter fw = new FileWriter("buf.txt");

//为了提高效率。创建缓冲区对象,并和要被提高效率的流相关联。
BufferedWriter bufw = new BufferedWriter(fw);

for(int x=0;x<4; x++){
bufw.write(x+"--hahaha");
//写入一个换行符。
bufw.newLine();
//要对缓冲区进行刷新。记住:一般只要使用了缓冲区,就一定要刷新。
bufw.flush();
}

//关闭缓冲区。
bufw.close();//问:还用关闭fw.close()?不用,因为关闭缓冲区,其实就是在关闭缓冲区关联的流。

}
}

在上述示例中,我们应当注意:

1.      写入一个新行的方法:newline();

2.      每写一次,就要讲缓冲区刷新一次。

3.      在使用完后,关闭缓冲区即可,不需要在关闭流。因为流已经与缓冲区相关联了。

 

 

至此:我们已经学习了IO体系中的四个对象:

 

FileReader  FileWriter  BufferedReader BufferedWriter