08 Java当中的输入输出流的学习笔记 基本IO(5篇范例)

时间:2019-05-13 16:14:15下载本文作者:会员上传
简介:写写帮文库小编为你整理了多篇相关的《08 Java当中的输入输出流的学习笔记 基本IO》,但愿对你工作学习有帮助,当然你在写写帮文库还可以找到更多《08 Java当中的输入输出流的学习笔记 基本IO》。

第一篇: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();

}

}

下载08 Java当中的输入输出流的学习笔记 基本IO(5篇范例)word格式文档
下载08 Java当中的输入输出流的学习笔记 基本IO(5篇范例).doc
将本文档下载到自己电脑,方便修改和收藏,请勿使用迅雷等下载。
点此处下载文档

文档为doc格式


声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:645879355@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。

相关范文推荐

    Java 实验 文件管理与IO流

    作业要求:每个题保存为一个.java文件,保存在同一工程文件夹中,文件夹的名字为E:Java你的班级+姓名,例如:E:Java信息11张三。 注意:上交的程序包含程序的执行结果,以注释的形式......

    实验12:Java高级IO流程序设计

    实验12:Java高级I/O流程序设计 实验时间:实验地点: 一、实验目的及要求 (1)掌握文件类File的使用。 (2)理解随机存取文件类RandomAccessFile的使用。 二、实验设备环境及要求三、实......

    Java实验五 IO流的一般使用

    Java实验五IO流的一般使用 实验目的:掌握文件类的使用,了解一般流的基本应用。加深处理代码的能力。 实验内容: import java.io.* ;public class lijun43 { public static void......

    使用java输入输出流实现文件的复制

    使用java输入输出流实现文件的复制: public class Test {public static void copy(File source,File target){ InputStream in=null; OutputStream out=null; try { in=new B......

    《Java面向对象程序设计》实验-实验八(输入输出流)(合集)

    广西科技大学 计通学院 《Java面向对象程序设计》实验 实验八输入输出流 学生姓名:××× 学号:××× 班级:××× 指导老师:××× 专业:计算机科学与技术提交日期:×××年××......

    Java IO流将信息写入文本文件档

    public class Test{ public static void main(String[] args) { try { BufferedWriter bw = new BufferedWriter(new FileWriter("data.txt")); //文件将会创建在程序所在的......

    java学习笔记

    jdk(java development kit)有如下公司或组织开发jdksun jdkibm jdkbea jrocketgun jdk其中ibm的jdk包含的jvm(java virtual machine)运行效率要比sun jdk包含的jvm高出许多。......

    java学习笔记(更新)

    1.JSP内置对象分类 与Servlet有关的隐含对象 page、config 与Input/Output有关的隐含对象out、request、response JSP执行时,提供有关Context的隐含对象 session、applicatio......