1.字符流
Reader(读)Writer(写)
Reader
InputStreamReader FileReader:用于处理文件的字符读取流对象
Writer
OutputStreamWriter FileWriter:用于处理文件的字符写入流对象
其实很容易就可以看出来,IO体系中的子类名后缀绝大部分是父类名称,而前缀则是体现子类特有功能的名称。
Reader中常见的方法:
(1)int read()读取一个字符,并返回读到的这个字符,读到流的末尾则返回-1。
(2)int read(char[]) 将读到的字符存入指定的数组中,返回的是读到的字符个数,读到流的末尾则返回-1。
(3)close() 读取字符其实用的是window系统的功能,就希望使用完毕后,进行资源的释放。
FileReader除了自己的构造函数外没有特有的方法:
用于读取文本文件的流对象。用于关联文本文件。
构造函数FileReader(String fileName)
在读取流对象初始化时,必须要指定一个被读取的文件, 如果该文件不存在则会发生FileNotFoundException异常。
Writer中常见的方法:
(1)write()将一个字符写入到流中。
(2)write(char[])将一个字符数组写入到流中。
(3)writer(String)将一个字符写入到流中。
(4)flush()刷新流,将流中的数据刷新到目的地中,流还存在。
(5)close()关闭资源,在关闭钱会先调用flush(), 刷新流中的数据到目的地。
FileWriter,除了自己的构造函数外没有特有的方法:
该类的特点,用于处理文本文件、没有默认的编码表、有临时缓冲、构造函数,在写入流对象初始化时,必须要有一个存储数据的目的地。
FileWriter(String fileName),该构造器是干什么用的呢?
调用系统资源、在指定位置创建一个文件,如果该文件已经存在则被覆盖。FileWriter(String filename,Boolean append),这构造器的作用是?
当传入的boolean类型的值为true时,会在指定文件末尾处进行数据的续写。
清单1,将文本数据保存到文件中代码
private static void test1(){
FileWriter fw=null;
try {
//初始化FileWriter对象,指定文件名已经存储路径
fw=new FileWriter("D:/test.txt");
fw.write("将字符串写入流");
//将流中的数据刷新到目的地,流还在
fw.flush();
fw.write("将字符串写入流");
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fw!=null){
try {
fw.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
清单2,读取一个已有文本文件,并将文本内容打印出来代码
private static void test2(){
FileReader fr=null;
try {
//初始化FileReader对象,指定文件路径
fr=new FileReader("D:/test.txt");
int ch=0;
while((ch=fr.read())!=-1){
//每次读取一个字符,直到读到末尾-1为止
System.out.println((char)ch);
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fr!=null){
try {
fr.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
样每读到一个字符就打印出来,效率很不高,能不能按指定大小读取完后再打印出来呢?答案是当然可以的。
清单3,读取一个已有文本文件,读完1kb再将其读到的内容打印出来代码
private static void test3(){
FileReader fr=null;
try {
//初始化FileReader对象,指定文件路径
fr=new FileReader("D:/test.txt");
char[] buf=new char[1024];
int len=0;
while((len=fr.read(buf))!=-1){
//每次读取1kb大小的字符,直到读到末尾-1为止
System.out.println(new String(buf,0,len));
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(fr!=null){
try {
fr.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
字符流的缓冲区
|--缓冲区的出现提高了对流的操作效率。
原理:其实就是将数组进行封装。
|--对应的对象
|--BufferedWriter
特有方法newLine(),跨平台的换行符。
|--BufferedReader
特有方法readLine(),一次读一行,到行标记时,将行标记
之前的字符数据作为字符串返回,读到末尾返回null。
|--说明
在使用缓冲区对象时,要明确,缓冲的存在是为了增强流
的功能而存在,所以在建立缓冲区对象时,要先有流对象
存在。其实缓冲区内部就是在使用流对象的方法,只不过
加入了数组对数据进行了临时存储,为了提高操作数据的
效率。
|--代码上的体现
|--写入缓冲区对象
根据前面所说的建立缓冲区时要先有流对象,并将其作为参数传递给缓冲区的构造函数
BufferedWriter bufw=new BufferedWriter(new FileWriter(“test.txt”));
bufw.write(“将数据写入缓冲区”);
bufw.flush();//将缓冲区的数据刷新到目的地
bufw.close();//其实关闭的是被包装在内部的流对象
|--读取缓冲区对象
BufferedReader bufr=new BufferedReader(new FileReader(“test.txt”));
String line=null;
while((line=bufr.readLine())!=null){
//每次读取一行,取出的数据不包含回车符
system.out.println(line);
}
bufr.close();
清单4,使用缓冲区对文本文件进行拷贝代码
private static void test4(){
BufferedReader bufr=null;
BufferedWriter bufw=null;
try {
bufr=new BufferedReader(new FileReader("D:/a.txt"));
bufw=new BufferedWriter(new FileWriter("D:/b.txt"));
String line=null;
while((line=bufr.readLine())!=null){
bufw.write(line);//每次将一行写入缓冲区
bufw.flush();//刷新到目的地
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(bufw!=null){
bufw.close();
}
if(bufr!=null){
bufr.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
仔细看可以发现,程序里面的FileReader对象和FileWriter对象直接new出来且没有调用close(),因为缓冲对象调用了这两个方法,前面说了,缓冲对象调用的flush()和close()其实就是关闭被包装在其内部的流对象。关闭流的先后顺序也要注意,如果流之间有依赖关系,则被依赖的流要后关闭。readLine()方法原理:其实缓冲区中的该方法,用的还是与缓冲区关联的流对象的read方法,只不过,每一次读到一个字符先不进行具体操作,先进行临时存储,当读到回车标记时,将临时容器中存储的数据一次性返回。我们可以根据这个原理来自己编写一个缓冲区对象。
清单5,编写一个自己的bufferedreader代码
public class MyBufferedReader {
private Reader reader;
public MyBufferedReader(Reader reader){
this.reader=reader;
}
public String readLine() throws IOException{
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=reader.read())!=-1){
if(ch=='\r'){//空格则继续
continue;
}else if(ch=='\n'){//每次返回一行
return sb.toString();
}else{
sb.append((char)ch);
}
}
return sb.toString();
}
public void close() throws IOException{
//缓冲对象的关闭方法其实就是调用流本身的close()
reader.close();
}
}
测试时把清单4的BufferedReader对象替换成MyBufferedReader对象即可。
清单6,测试mybufferedreader代码
private static void test4(){
MyBufferedReader bufr=null;
BufferedWriter bufw=null;
try {
bufr=new MyBufferedReader(new FileReader("D:/a.txt"));
bufw=new BufferedWriter(new FileWriter("D:/b.txt"));
String line=null;
while((line=bufr.readLine())!=null){
bufw.write(line);//每次将一行写入缓冲区
bufw.flush();//刷新到目的地
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(bufw!=null){
bufw.close();
}
if(bufr!=null){
bufr.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
2.字节流
|-- InputStream(读)
|-- OutputStream(写)
由于字节是二进制数据,所以字节流可以操作任何类型的数据,值得注意的是字符流使用的是字符数组char[]而字节流使用的是字节数组byte[]。下面来看一个字节流读写文件的简单例子。
清单7,使用字节流读写文本文件代码
private static void test5(){
FileOutputStream fos=null;
try{
fos=new FileOutputStream("D:/test.txt");
fos.write(0010);//写入二进制数据
fos.flush();
}catch(IOException e){
}finally{
try{
fos.close();
}catch(IOException ex){
}
}
FileInputStream fis=null;
try{
fis=new FileInputStream("D:/test.txt");
//fis.available()是获取关联文件的字节数,即test.txt的字节数
//这样创建的数组大小就和文件大小刚好相等
//这样做的缺点就是文件过大时,可能超出jvm的内存空间,从而造成内存溢出
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
}catch(IOException e){
}finally{
try{
fos.close();
}catch(IOException ex){
}
}
}
清单8,使用缓冲区对一张图片进行复制代码
private static void test6(){
BufferedOutputStream bos=null;
BufferedInputStream bis=null;
try{
//前面已经说过了,缓冲对象是根据具体的流对象创建的,所以必须要有流对象
bis=new BufferedInputStream(new FileInputStream("E:\\images\\wo\\1.jpg"));
//写入目标地址
bos=new BufferedOutputStream(new FileOutputStream("E:\\test.jpg"));
byte[] buf=new byte[1024];
while((bis.read(buf))!=-1){
bos.write(buf);
}
bos.flush();
}catch(IOException e){
e.toString();
}finally{
try{
if(bos!=null){
bos.close();
}
if(bis!=null){
bis.close();
}
}catch(IOException ex){
ex.toString();
}
}
}
3.转换流
特点:
是字节流和字符流之间的桥梁
该流对象可以对读取到的字节数据进行指定编码表的编码转换
何时使用:
当字节和字符之间有转换动作时
流操作的数据需要进行编码表的指定时
具体对象体现:
InputStreamReader:字节到字符的桥梁
OutputStreamWriter:字符到字节的桥梁
说明:
这两个流对象是字符流体系中的成员,它们有转换的作用,而本身又是字符流,所以在new的时候需要传入字节流对象。
构造函数:
InputStreamReader(InputStream)
通过该构造函数初始化,使用的是系统默认的编码表GBK。
InputStreamReader(InputStream,String charset)
通过该构造函数初始化,可以通过charset参数指定编码。
OutputStreamWriter(OutputStream)
使用的是系统默认的编码表GBK。
OutputStreamWriter(OutputSream,String charset)
通过该构造函数初始化,可以通过参数charset指定编码。
操作文件的字符流对象是转换流的子类
Reader
inputStreamReader(转换流)
FileReader(文件字符流)
Writer
OutputStreamWriter(转换流)
FileWriter(文件字符流)
说明:
转换流中的read方法,已经融入了编码表,在底层调用字节流的read方法时将获取的一个或者多个字节数据进行临时存储,并去查指定的编码表,如果编码没有指定,则使用默认编码表。既然转换流已经完成了编码转换的动作,对于直接操作的文本文件的FileReader而言,就不用再重新定义了,只要继承该转换流,获取其方法,就可以直接操作文本文件中的字符数据了
注意:
在使用FileReader操作文本数据时,该对象使用的是默认的编码表, 如果要使用指定的编码表,必须使用转换流。
代码体现:
FileReader fr=new FileReader(“test.txt”);
InputStreamReader isr=new InputStreamReader(ne
FileInputStreamReader(“test.txt”));
这两句代码意义相同,操作test.txt中的数据都是使用了系统默认的编码GBK。因为我们系统默认使用的编码表是GBK,如果test.txt中的数据是通过UTF-8形式编码的,那么在读取的时候就需要指定编码表,因此转换流必须使用InputStreamReader isr=newInputStreamReader(new FileInputStream(“a.txt”),”UTF-8”);
四、流操作的基本规律
明确数据源和数据汇(数据目的)其实是为了明确是输入流还是输出流
明确操作的数据是否是纯文本数据
说明:
数据源:
键盘System.in、硬盘、File开头的流对象、内存(数组)。
数据汇:
控制台System.out、硬盘、File开头的流对象、内存(数组)。
需求
将键盘录入的数据存储到一个文件中和打印到控制
数据源System.in
既然是源,使用的就是输入流,可用的体系有InputStream、Reader。因为键盘录入进来的一定是纯文本数据,所以 可以使用专门操作字符数据的Reader。而System.in对应的流是字节读取流,所以要将其进行转换,将字节转换成字符即可,所以要使用Reader体系中的InputStreamReader,
如果要提高效率,就使用BufferedReader,代码如:
BufferedReader bur=new BufferedReader(new
InputStreamReader(Sysem.in));
数据汇:一个文件、硬盘
数据汇一定是输出流,可以用的体系有OutputStream、
Writer。往文件中存储的都是文本数据,那么可以使用字符
流较为方便Writer。因为操作的是一个文件,所以使用Wri
中的FileWriter,同理,要提高效率就要使用BufferedWriter
代码如:BufferedWriter bufr=new BufferedWriter(newFileWriter(“test.txt”));
清单9,将键盘录入的数据存储到一个文件中和打印到控制台代码
private static void test7(){
BufferedReader bur=null;
OutputStreamWriter osw=null;
BufferedWriter bw=null;
try{
//数据源
bur=new BufferedReader(new InputStreamReader(System.in));
//数据汇
osw=new OutputStreamWriter(System.out);
//数据汇,因为数据源用的是系统默认编码,所以这里可以直接使用FileWriter
//否则必须使用OutputStreamWriter转换流
bw=new BufferedWriter(new FileWriter("D:\\test_target.txt"));
String line=null;
while((line=bur.readLine())!=null){
osw.write(line);
osw.flush();//刷新到控制台
bw.write(line);
bw.flush();//刷新到文本文件
}
}catch(IOException e){
e.toString();
}finally{
try{
if(osw!=null){
osw.close();
}
if(bur!=null){
bur.close();
}
if(bw!=null){
bw.close();
}
}catch(IOException ex){
ex.toString();
}
}
}
清单9是按照默认编码表写入文本文件的,那么如何按照指定编码表写入文件呢?其实也很简单,将清单9的代码稍微改一下就可以
清单10代码
private static void test8(){
BufferedReader bur=null;
BufferedWriter bw=null;
try{
//数据源
bur=new BufferedReader(new InputStreamReader(System.in));
//数据汇,按照指定编码格式存储到文本文件
bw=new BufferedWriter(new OutputStreamWriter(new
FileOutputStream("D:\\test_target.txt"),"UTF-8"));
String line=null;
while((line=bur.readLine())!=null){
bw.write(line);
bw.flush();//刷新到文本文件
}
}catch(IOException e){
e.toString();
}finally{
try{
if(bur!=null){
bur.close();
}
if(bw!=null){
bw.close();
}
}catch(IOException ex){
ex.toString();
}
}
}
既然写入文件时指定了编码,那么在读取的时候就必须指定该编码才能正确显示。
清单11,读取指定编码表的文件代码
private static void test9() {
BufferedReader bur = null;
try {
// 注意,这里读取的是清单8写入的文件,
// 清单10用UTF-8编码格式写入,
// 所以在构造InputStreamReader时必须指定UTF-8编码
bur = new BufferedReader(new InputStreamReader(
new FileInputStream("D:\\test_target.txt"), "UTF-8"));
String line = null;
while ((line = bur.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.toString();
} finally {
try {
if (bur != null) {
bur.close();
}
} catch (IOException ex) {
ex.toString();
}
}
}
写入和读取都做了,现在还差个复制操作,其实复制文件也很简单,先读取文件,再将读取到的数据写入文件,不同的是,在读取和写入时我们可以指定编码表。
清单12代码
private static void test11() {
BufferedReader bur = null;
BufferedWriter buw = null;
try {
bur = new BufferedReader(new InputStreamReader(
new FileInputStream("D:\\test_target.txt"), "UTF-8"));
buw = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream("D:\\test_target1.txt"),"UTF-8"));
String line = null;
while ((line = bur.readLine()) != null) {
buw.write(line);
buw.flush();// 刷新到文本文件
}
} catch (IOException e) {
e.toString();
} finally {
try {
if (buw != null) {
buw.close();
}
if (bur != null) {
bur.close();
}
} catch (IOException ex) {
ex.toString();
}
}
}