第一篇:08 Java当中的输入输出流的学习笔记 基本IO
流的分类:
输入流(InputStream/Reader),输出流(OutputStream/Writer)
字节流(InputStream,OutputStream)字符流(Reader/Writer)
节点流(InputStream/Reader,OutputStream/Writer),处理流(过滤流)BufferedIO(缓冲),DataInputStream/DataOutputStream(各种数据类型), InputStreamReader/OutputStreamWriter(转换流),ByteArrayInputStream/ ByteArrayOutputStream(内存数组流)PipedInputStream/ PipedOutputStream(管道流,线程间通讯)
1.或者OutputStream可以创建一个文件,但是不能创建一个文件夹。
2.InputStream(OutputStream)和Reader(Writer)的区别在于字节和字符,对于非标准ASCII
编码(占用两个字节的字符)字节流会出现乱码。
3.使用bufferedIO是为了readline()方法和write(s),s是一个字符串。而且
bufferedinPutStream有mark和reset方法。
4.InputStreamReader和OutputStreamWriter可以把字节流转换为字符流。
InputStreamReader需要和InputStream套接。OutputStreamWriter需要和OutputStream套接。OutputStreamWriter可以写一个字符串。还有一个典型的应用就是在于对于System.in的处理。
InputStreamReaderisr =
newInputStreamReader(System.in);
BufferedReaderbr = newBufferedReader(isr);
System.in是一个InputStream的子类,需要把它改成InputStreamReader然后使用BufferedReader读出每行的内容。
5.DataInputStream,DataOutputStream是用来对付原始的数据类型,比如int,long,double,float 和UTF。
6.ByteArrayInputStream和ByteArrayOutputStream在内存中创建一个字节数组。
import java.io.*;
publicclassTestDataStream {
publicstaticvoid main(String[] args){
ByteArrayOutputStreambaos =
newByteArrayOutputStream();//在内存中创建了一个内存字节数组,并对上一个管道baos DataOutputStream dos =
newDataOutputStream(baos);//使用DataOutputStream是为了使用writeDouble,writeBoolean等方法
try {
dos.writeDouble(Math.random());//在字节数组当中写入8个字节的double类型的数字 dos.writeBoolean(true);//在字节数组中写入一个boolean类型的true,占用1个字节
ByteArrayInputStreambais =
newByteArrayInputStream(baos.toByteArray());//bais也对到由baos对应的内存字节数组
System.out.println(bais.available());//内存数组当中有多少字节可用(也就是说被写入了多少个字节的内容)
DataInputStream dis = newDataInputStream(bais);//使用DataInputStream是为了使用readDouble,readBoolean等方法
System.out.println(dis.readDouble());//先写进去的东西要先读是队列
System.out.println(dis.readBoolean());//后写进去的东西要后读
dos.close();
dis.close();
} catch(IOException e){
e.printStackTrace();
}
}
}
7.PipedInputStream和PipedOutputStream是管道流,用于线程间的通信。一个线程的PipedInputStream对象必须从另一个线程的PipedOutputStream对象读取输入。要使用管道流,必须同时构造管道输入流和输出流。
8.Print流就只有输出流,没有输入流。
Print流不会抛异常,而且都会自动flush。
System.setOut(ps);//修改系统输出的位置
9.Object流和序列化问题
将对象转换为字节流并保存起来(文件,磁盘,网络),这种机制叫做对象序列化。并在日后还原这个对象,这种机制叫对象的反序列化。将一个对象保存到永久存储设备上称为持续性。
使用ObjectOutputStream和ObjectInputStream来专门用来把一个object写入或者读出硬盘上。(常用于游戏存盘?)其做法是把整个的object写入磁盘或者读出。
当一个对象被序列化时,只保存对象的非静态成员变量,不能保存任何的成员方法和静态的成员变量。如果一个对象的成员变量是一个对象,那么这个对象的数据成员也会被保存。
为了把一个类的对象写到硬盘或者网络,就必须实现serializable接口或Externalizable接口。区别是在于和Externalizable(外部化)是接口是抽象方法,必须被实现。而Serializable(序列化)是一个标示形接口,也就是说,这样的接口是没有方法。Java当中还有很多这样的接口。但是我们必须实现这个接口,这个接口的意义是在于让java编译器知道这个该类需要实现了这个功能。要注意,如果该类没有实现这个接口,会抛出一个NotSerializableException。
有的时候,一个可序列化的对象包含对某个不可序列化的对象的引用,那么整个序列化操作将会失败,并且会抛出一个NotSerializableException。为了解决这个问题,可以将这个引用标记为transient,那么对象仍然可以序列化。也就是说,transient修饰的成员变量在序列化的时候,是不给予考虑的,也就是说被transient修饰的内容是不会被保存的。
Externalizable接口当中有两个抽象方法,必须被实现.
第二篇:JAVA,IO流学习总结
篇一:java之io流学习总结 java之io流学习总结
一、什么是流?
流就是字节序列的抽象概念,能被连续读取数据的数据源和能被连续写入数据的接收端就是流,流机制是java及c++中的一个重要机制,通过流我们可以自由地控制文件、内存、io设备等数据的流向。而io流就是用于处理设备上的数据,如:硬盘、内存、键盘录入等。io流根据处理类型的不同可分为字节流和字符流,根据流向的不同可分为输入流和输出流。
二、字节流和字符流的区别:字符流,因为文件编码的不同,就有了对字符进行高效操作的字符流对象,它的原理就是基于字节流读取字节时去查了指定的码表。它和字节流的区别有两点:1.在读取数据的时候,字节流读到一个字节就返回一个字节,字符流使用了字节流读到一个或多个字节(一个中文对应的字节数是两个,在utf-8码表中是3个字节)时,先去查指定的编码表,再将查到的字符返回;2.字节流可以处理所有类型的数据,如jpg、avi、mp3、wav等等,而字符流只能处理字符数据。所以可以根据处理的文件不同考虑使用字节流还是字符流,如果是纯文本数据可以优先考虑字符流,否则使用字节流。
三、io体系,所具备的基本功能就是读和写: 1.字符流
|--reader(读)|--writer(写)reader |--inputstreamreader |--filereader:用于处理文件的字符读取流对象 writer |--outputstreamwriter |--filewriter:用于处理文件的字符写入流对象
其实很容易就可以看出来,io体系中的子类名后缀绝大部分是父类名称,而前缀则是体现子类特有功能的名称。reader中常见的方法: |--int read()读取一个字符,并返回读到的这个字符,读到流的末尾则返回-1。|--int read(char[])将读到的字符存入指定的数组中,返回的是读到的字符个数,读到流的末尾则返回-1。|--close()读取字符其实用的是window系统的功能,就希望使用完毕后,进行资源的释放。filereader除了自己的构造函数外没有特有的方法: |--用于读取文本文件的流对象。
|--用于关联文本文件。在读取流对象初始化时,必须要指定一个被读取的文件,如果该文件不存在则会发生filenotfoundexception异常。writer中常见的方法: |--write()将一个字符写入到流中。|--write(char[])将一个字符数组写入到流中。|--writer(string)将一个字符写入到流中。|--flush()刷新流,将流中的数据刷新到目的地中,流还存在。|--close()关闭资源,在关闭钱会先调用flush(),刷新流中的数据到目的地。filewriter,除了自己的构造函数外没有特有的方法: |--该类的特点
|--用于处理文本文件 |--没有默认的编码表 |--有临时缓冲
|--构造函数,在写入流对象初始化时,必须要有一个存储数据的目的地。|--filewriter(string filename),该构造器是干什么用的呢? |--调用系统资源
|--在指定位置创建一个文件,如果该文件已经存在则被覆盖。
|--filewriter(string filename,boolean append),这构造器的作用是当传入的boolean类型的值为true时,会在指定文件末尾处进行数据的续写。
清单1,将文本数据保存到文件中代码 private static void test1(){filewriter fw=null;//初始化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){篇二:java io流学习总结 java流操作有关的类或接口:
java流类图结构:流的概念和作用
流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。io流的分类
? 根据处理数据类型的不同分为:字符流和字节流 ? 根据数据流向不同分为:输入流和输出流
字符流和字节流
字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。字节流和字符流的区别:
? 读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射 字符,一次可能读多个字节。
? 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处 理字符类型的数据。
结论:只要是处理纯文本数据,就优先考虑使用字符流。除此之外都使用字节流。输入流和输出流
对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。java io流对象
1.输入字节流inputstreamio 中输入字节流的继承图可见上图,可以看出: 1.inputstream 是所有的输入字节流的父类,它是一个抽象类。
2.bytearrayinputstream、stringbufferinputstream、fileinputstream 是三种基本的介质
流,它们分别从byte 数组、stringbuffer、和本地文件中读取数据。pipedinputstream 是从与其它线程共用的管道中读取数据,与piped 相关的知识后续单独介绍。3.objectinputstream 和所有filterinputstream 的子类都是装饰流(装饰器模式的主角)。2.输出字节流outputstream io 中输出字节流的继承图可见上图,可以看出:
1.outputstream 是所有的输出字节流的父类,它是一个抽象类。2.bytearrayoutputstream、fileoutputstream 是两种基本的介质流,它们分别向byte 数 组、和本地文件中写入数据。pipedoutputstream 是向与其它线程共用的管道中写入数据,3.objectoutputstream 和所有filteroutputstream 的子类都是装饰流。3.字节流的输入与输出的对应
图中蓝色的为主要的对应部分,红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出java io 中的字节流是极其对称的。“存在及合理”我们看看这些字节流中不太对称的几个类吧!
1.linenumberinputstream 主要完成从流中读取数据时,会得到相应的行号,至于什么 时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个linenumberoutputstream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。
2.pushbackinputstream 的功能是查看最后一个字节,不满意就放入缓冲区。主要用在 编译器的语法、词法分析部分。输出部分的bufferedoutputstream 几乎实现相近的功能。3.stringbufferinputstream 已经被deprecated,本身就不应该出现在inputstream 部分,主要因为string 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。
4.sequenceinputstream 可以认为是一个工具类,将两个或者多个输入流当成一个输入 流依次读取。完全可以从io 包中去除,还完全不影响io 包的结构,却让其更“纯洁”――纯洁的decorator 模式。
5.printstream 也可以认为是一个辅助工具。主要可以向其他输出流,或者
fileinputstream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出io 包!system.out 和system.out 就是printstream 的实例!4.字符输入流reader在上面的继承关系图中可以看出: 1.reader 是所有的输入字符流的父类,它是一个抽象类。
2.charreader、stringreader 是两种基本的介质流,它们分别将char 数组、string中 读取数据。pipedreader 是从与其它线程共用的管道中读取数据。
3.bufferedreader 很明显就是一个装饰器,它和其子类负责装饰其它reader 对象。4.filterreader 是所有自定义具体装饰流的父类,其子类pushbackreader 对reader 对 象进行装饰,会增加一个行号。
5.inputstreamreader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。filereader 可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将fileinputstream 转变为reader 的方法。我们可以从这个类中得到一定的技巧。reader 中各个类的用途和使用方法基本和inputstream 中的类使用一致。后面会有reader 与inputstream 的对应关系。5.字符输出流writer 在上面的关系图中可以看出:
1.writer 是所有的输出字符流的父类,它是一个抽象类。2.chararraywriter、stringwriter 是两种基本的介质流,它们分别向char 数组、string 中写入数据。pipedwriter 是向与其它线程共用的管道中写入数据,3.bufferedwriter 是一个装饰器为writer 提供缓冲功能。
4.printwriter 和printstream 极其类似,功能和使用也非常相似。5.outputstreamwriter 是outputstream 到writer 转换的桥梁,它的子类filewriter 其 实就是一个实现此功能的具体类(具体可以研究一sourcecode)。功能和使用和outputstream 极其类似,后面会有它们的对应图。6.字符流的输入与输出的对应 7.字符流与字节流转换 转换流的特点:
1.其是字符流和字节流之间的桥梁
2.可对读取到的字节数据经过指定编码转换成字符 3.可对读取到的字符数据经过指定编码转换成字节 何时使用转换流?
1.当字节和字符之间有转换动作时; 2.流操作的数据需要编码或解码时。具体的对象体现:
1.inputstreamreader:字节到字符的桥梁 2.outputstreamwriter:字符到字节的桥梁
这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。8.file类
file类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。file类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。篇三:java io流学习总结 java流操作有关的类或接口:
java流类图结构:流的概念和作用
流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。io流的分类
根据处理数据类型的不同分为:字符流和字节流 ? 根据数据流向不同分为:输入流和输出流 ? 字符流和字节流
字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。字节流和字符流的区别:
读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
? 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。? 结论:只要是处理纯文本数据,就优先考虑使用字符流。除此之外都使用字节流。
输入流和输出流
对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。java io流对象
1.输入字节流inputstreamio 中输入字节流的继承图可见上图,可以看出: 1.inputstream 是所有的输入字节流的父类,它是一个抽象类。
2.bytearrayinputstream、stringbufferinputstream、fileinputstream 是三种基本的介质流,它们分别从byte 数组、stringbuffer、和本地文件中读取数据。pipedinputstream 是从与其它线程共用的管道中读取数据,与piped 相关的知识后续单独介绍。3.objectinputstream 和所有filterinputstream 的子类都是装饰流(装饰器模式的主角)。2.输出字节流outputstream io 中输出字节流的继承图可见上图,可以看出:
1.outputstream 是所有的输出字节流的父类,它是一个抽象类。2.bytearrayoutputstream、fileoutputstream 是两种基本的介质流,它们分别向byte 数组、和本地文件中写入数据。pipedoutputstream 是向与其它线程共用的管道中写入数据,3.objectoutputstream 和所有filteroutputstream 的子类都是装饰流。3.字节流的输入与输出的对应
图中蓝色的为主要的对应部分,红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出java io 中的字节流是极其对称的。“存在及合理”我们看看这些字节流中不太对称的几个类吧!1.linenumberinputstream 主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部 分,我们完全可以自己建立一个linenumberoutputstream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行 号,看起来也是可以的。好像更不入流了。2.pushbackinputstream 的功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的
bufferedoutputstream 几乎实现相近的功能。3.stringbufferinputstream 已经被deprecated,本身就不应该出现在inputstream 部分,主要因为string 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。4.sequenceinputstream 可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从io 包中去除,还完全不影响io 包的结构,却让其更“纯洁”――纯洁的decorator 模式。5.printstream 也可以认为是一个辅助工具。主要可以向其他输出流,或者fileinputstream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出io 包!system.out 和system.out 就是printstream 的实例!4.字符输入流reader 在上面的继承关系图中可以看出:
1.reader 是所有的输入字符流的父类,它是一个抽象类。
2.charreader、stringreader 是两种基本的介质流,它们分别将char 数组、string中读取数据。pipedreader 是从与其它线程共用的管道中读取数据。
3.bufferedreader 很明显就是一个装饰器,它和其子类负责装饰其它reader 对象。4.filterreader 是所有自定义具体装饰流的父类,其子类pushbackreader 对reader 对象进行装饰,会增加一个行号。
5.inputstreamreader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。filereader 可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将fileinputstream 转变为reader 的方法。我们可以从这个类中得到一定的技巧。reader 中各个类的用途和使用方法基本和inputstream 中的类使用一致。后面会有reader 与inputstream 的对应关系。5.字符输出流writer 在上面的关系图中可以看出:
1.writer 是所有的输出字符流的父类,它是一个抽象类。2.chararraywriter、stringwriter 是两种基本的介质流,它们分别向char 数组、string 中写入数据。pipedwriter 是向与其它线程共用的管道中写入数据,3.bufferedwriter 是一个装饰器为writer 提供缓冲功能。
4.printwriter 和printstream 极其类似,功能和使用也非常相似。5.outputstreamwriter 是outputstream 到writer 转换的桥梁,它的子类filewriter 其实就是一个实现此功能的具体类(具体可以研究一 sourcecode)。功能和使用和outputstream 极其类似,后面会有它们的对应图。
第三篇:Java之IO流学习总结
Java之IO流学习总结
一、什么是流?
流就是字节序列的抽象概念,能被连续读取数据的数据源和能被连续写入数据的接收端就是流,流机制是Java及C++中的一个重要机制,通过流我们可以自由地控制文件、内存、IO设备等数据的流向。而IO流就是用于处理设备上的数据,如:硬盘、内存、键盘录入等。IO流根据处理类型的不同可分为字节流和字符流,根据流向的不同可分为输入流和输出流。
字符流,因为文件编码的不同,就有了对字符进行高效操作的字符流对象,它的原理就是基于字节流读取字节时去查了指定的码表。它和字节流的区别有两点:1.在读取数据的时候,字节流读到一个字节就返回一个字节,字符流使用了字节流读到一个或多个字节(一个中文对应的字节数是两个,在UTF-8码表中是3个字节)时,先去查指定的编码表,再将查到的字符返回;2.字节流可以处理所有类型的数据,如jpg、avi、mp3、wav等等,而字符流只能处理字符数据。所以可以根据处理的文件不同考虑使用字节流还是字符流,如果是纯文本数据可以优先考虑字符流,否则使用字节流。
三、IO体系,所具备的基本功能就是读和写: 1.字符流
|--Reader(读)|--Writer(写)Reader
|--InputStreamReader
|--FileReader:用于处理文件的字符读取流对象 Writer
|--OutputStreamWriter
|--FileWriter:用于处理文件的字符写入流对象
其实很容易就可以看出来,IO体系中的子类名后缀绝大部分是父类名称,而前缀则是体现子类特有功能的名称。Reader中常见的方法: |--int read()
读取一个字符,并返回读到的这个字符,读到流的末尾则返回-1。|--int read(char[])
将读到的字符存入指定的数组中,返回的是读到的字符个数,读到流的末尾则返回-1。|--close()
读取字符其实用的是window系统的功能,就希望使用完毕后,进行资源的释放。FileReader除了自己的构造函数外没有特有的方法: |--用于读取文本文件的流对象。|--用于关联文本文件。
|--构造函数FileReader(String fileName)在读取流对象初始化时,必须要指定一个被读取的文件,如果该文件不存在则会发生FileNotFoundException异常。Writer中常见的方法: |--write()
将一个字符写入到流中。|--write(char[])
将一个字符数组写入到流中。|--writer(String)将一个字符写入到流中。|--flush()
刷新流,将流中的数据刷新到目的地中,流还存在。|--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();} } }
其实我们自己写的这个缓存对象就是对Reader对象进行了功能的增强,Reader对象每次只能返回一个字符,而增强了功能之后该类就可以每次返回一行字符,也就是设计模式中所说的装饰模式。
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:imageswo1.jpg”));//写入目标地址
bos=new BufferedOutputStream(new FileOutputStream(“E: est.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(new 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(newInputStreamReader(Sysem.in));
|--数据汇:一个文件、硬盘
数据汇一定是输出流,可以用的体系有OutputStream、Writer。往文件中存储的都是文本数据,那么可以使用字符流较为方便Writer。因为操作的是一个文件,所以使用Writer中的FileWriter,同理,要提高效率就要使用BufferedWriter。
代码如:BufferedWriter bufr=new BufferedWriter(new
FileWriter(“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: est_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: est_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: est_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: est_target.txt”), “UTF-8”));buw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“D: est_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();} } }
第四篇:java 文件与输入输出流
实验2文件与输入输出流(1)
一、实验目的 能够使用File类表示文件或目录,获取相关信息,并进行文件操作; 能够利用InputStream和OutputStream的子类进行字节读、写操作,明白其优点及不足;
能够用FileInputStream和FileOutputStream进行文件读写的操作; 理解“逐层包装”思想,能够利用“数据流”(DataInputStream和DataOutputStream)包装字节流,方便各类数据的读写;
能够利用“缓冲字节流”(BufferedInputStream和BufferedOutputStream)包装字节流,加快数据的读写速度;
熟知System.in和System.out是PrintStream的实例。
二、实验步骤
在Eclipse环境中导入项目“code(lab_2)”,然后按要求完成各小题:
1.打开FileTest.java文件,请按下列要求进行操作:
(1)按要求填充程序所缺代码;
(2)程序的运行需要用到一个命令行参数,请分别用一个文件、目录作参数来运行程序,看一看结果有什么不同。
(在Eclipse中设置命令行参数方法:Run/Open Run Dialog „/(x)=Arguments设置)
2.在上一题的基础上,修改程序,使之具备输出指定目录下所有子目录中文件绝对路径名、大小的功能,如下所示:
子目录:C:jdk1.6.0sample
子目录:C:jdk1.6.0samplewebservices
子目录:C:jdk1.6.0samplewebservicesEbayServer
文件: C:jdk1.6.0samplewebservicesEbayServerbuild.properties,大小: 512 字节 文件: C:jdk1.6.0samplewebservicesEbayServerbuild.xml,大小: 3168 字节1
……
提示:参考课件 FileSpace.java内容,通过一个以“路径名”为参数的静态方法来实现:该方法先判断“路径名”是一个文件,还是一个目录?如果是文件,则输出其绝对路径和大小;若为一个目录,则先显示目录绝对路径,再列出该目录下的所有子目录和文件,通过循环和递归方法来执行后续处理。
3.文件FileOutputStreamTest.java的功能是:利用FileOutputStream类向myfile.txt文件写入'0'~'9'和“用字节流写入文件内容”,请填充程序所缺代码,并运行程序。然后打开myfile.txt文件,查看其内容是否与要求相符?
4.文件FileInputStreamTest1.java的功能是:利用FileInputStream类以“逐字节”方式读取myfile.txt文件内容,并输出。请填充程序所缺代码,并运行程序。问题:为什么程序输出的内容为乱码?
5.在FileInputStreamTest1.java的基础上,编写程序FileInputStreamTest2.java,利用FileInputStream类以“字节数组”方式读取myfile.txt文件内容,能正确输出,解决乱码问题。
思考题:乱码问题是怎样解决的?
6.若要将信息“Java开发典型模块大全”(书名)、“明日科技”(作者)、79.5(价格)等信息以UTF、double类型保存到文件books.txt中,请用“数据流”类编程实现。
第五篇:JAVA(IO流方法)
package Stream;
import java.io.*;
public class Io {
public void test1()throws Exception{
File file=new File(“E:/txt.txt”);
if(file.exists()){
System.out.println(“是否是文件:”+file.isFile());
System.out.println(“文件名是:”+file.getName());
System.out.println(“路径是:”+file.getPath());
System.out.println(“绝对路径是:”+file.getAbsolutePath());System.out.println(“上级目录是:”+file.getParent());System.out.println(“文件大小是:”+file.length()+“字节”);}
else {
file.createNewFile();
}
}
public void test2()throws Exception{//以字节流方式读取
File file=new File(“E:/txt1.txt”);
FileInputStream fi=new FileInputStream(file);
byte[] content= new byte[fi.available()];
/*for(int i=0;i content[i]=(byte)fi.read(); }//读取长度后,将其转换成字符型 *///第一种方式 fi.read(content);//第二种方式 String str=new String(content); System.out.println(str.trim()); } public void test3()throws Exception{//以字节流方式写入数据 File file=new File(“E:/txt1.txt”); FileOutputStream fo=new FileOutputStream(file); byte[]content=new String(“你是一个”).getBytes(); fo.write(content); content=new String(“呵呵”).getBytes(); fo.write(content); fo.close(); } public void test4()throws Exception{//用的缓冲方式文本读取 FileReader file=new FileReader(“E:/txt1.txt”); BufferedReader br=new BufferedReader(file); StringBuffer str=new StringBuffer(); String sw=br.readLine(); if(sw!=null){ str.append(sw+“ n”); } System.out.println(str); } public void test5()throws Exception{//用缓冲的方式写入数据然后再读入数据 FileWriter file=new FileWriter(“E:/txt1.txt”); BufferedWriter bw=new BufferedWriter(file); for(int i=1;i<=10;i++){ bw.write(“这是第”+i+“行”); bw.newLine(); } bw.close();//写放数据 FileReader file1=new FileReader(“E:/txt1.txt”); BufferedReader br=new BufferedReader(file1); StringBuffer str=new StringBuffer(); String sw=br.readLine(); if(sw!=null){ str.append(sw+“ n”); } System.out.println(str); } public void test6(){//删除文件 File file=new File(“E:/text.txt”); if(file.exists()){ System.out.println(“开始删除文件 :”+file.getPath());if(file.delete()){ System.out.println(“文件删除成功”); } else { System.out.println(“文件删除失败”); } } else { System.out.println(“该文件不存在”); } } public void test7()throws Exception{//创建 一个文件夹---创建一个目录或路径 File file=new File(“E:/txt1.txt”); if(file.exists()==false){ file.createNewFile(); } } public void test8()throws Exception {//* 将txt.txt复制文件到txt12.txt去;以字节流的的形式复制 File file=new File(“E:/txt.txt”); FileInputStream fi=new FileInputStream(file); byte[] content= new byte[fi.available()]; fi.read(content); fi.read(content, 0, content.length); String str=new String(content); System.out.println(str); File file1=new File(“E:/txt12.txt”); if(file.exists()==false){ file.createNewFile(); }//如果不存在该文件则创建一件文件 再行进复制 FileOutputStream fo=new FileOutputStream(file1,true);fo.write(content); fo.flush(); fo.close(); fi.close();//关闭流 } public void test9()throws Exception {//另和种方式复制文件--从缓冲的形式复制 FileReader file=new FileReader(“E:/txt.txt”); BufferedReader br=new BufferedReader(file); String str=br.readLine(); //从文件 里面读取出来 FileWriter file1=new FileWriter(“E:/txt1.txt”); BufferedWriter bw=new BufferedWriter(file1); while(str!=null){ bw.write(str); bw.newLine(); str = br.readLine(); } bw.flush(); bw.close(); br.close(); } public void test10()throws Exception{ File file=new File(“E:/txt.txt”); InputStream is = new FileInputStream(file); byte[] array = new byte[3]; int hasRead = 0; File file1=new File(“E:/txt1.txt”); OutputStream os = new FileOutputStream(file1); while((hasRead=is.read(array, 0, array.length))!=-1) { System.out.println(“读取了”+hasRead+“个字节”); for(int i=0;i { System.out.println(“第”+(i+1)+“个:”+array[i]); } /**每次从数组array里写入字节到文件 读多少写多少*/ os.write(array, 0, hasRead); } os.flush(); os.close(); is.close(); } public static void main(String args[])throws Exception{ Io t=new Io(); t.test9(); } }