java使用BufferedWriter写文件 - 为程序员服务
为程序员服务
java使用BufferedWriter写文件
当要写文本文件时最好使用Writer类，而不是直接写OutputStream；因为Writer类就是为写文本而设计的。
使用BufferedWriter写入文本时不用讲文本转换成字节数组。在下面的示例代码中我们向文件中写入两行文本。
import java.io.BufferedW
import java.io.FileNotFoundE
import java.io.FileW
import java.io.IOE
* @author outofmemory.cn
public class Main {
* Prints some data to a file using a BufferedWriter
public void writeToFile(String filename) {
BufferedWriter bufferedWriter =
//Construct the BufferedWriter object
bufferedWriter = new BufferedWriter(new FileWriter(filename));
//Start writing to the output stream
bufferedWriter.write(&Writing line one to file&);
bufferedWriter.newLine();
bufferedWriter.write(&Writing line two to file&);
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
//Close the BufferedWriter
if (bufferedWriter != null) {
bufferedWriter.flush();
bufferedWriter.close();
} catch (IOException ex) {
ex.printStackTrace();
* @param args the command line arguments
public static void main(String[] args) {
new Main().writeToFile(&myFile.txt&);
执行上述代码后文件中的文本如下:
Writing line one to file
Writing line two to file
注意使用BufferedWriter一定要在finally中flush()并close().
您可能的代码
相关聚客文章
荣誉：1400
相关专栏文章Java_IO流学习笔记 - 简书
Java_IO流学习笔记
一、IO流整体结构图
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。字符流和字节流字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。二、字符流
字符流输入输出关系对应字符输入流ReaderReader 是所有的输入字符流的父类，它是一个抽象类。CharReader、StringReader 是两种基本的介质流，它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。BufferedReader 很明显就是一个装饰器，它和其子类负责装饰其它Reader 对象。FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。字符输出流WriterWriter 是所有的输出字符流的父类，它是一个抽象类。CharArrayWriter、StringWriter 是两种基本的介质流，它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据，BufferedWriter 是一个装饰器为Writer 提供缓冲功能。PrintWriter 和PrintStream 极其类似，功能和使用也非常相似。OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter 其实就是一个实现此功能的具体类（具体可以研究一SourceCode）。功能和使用和OutputStream 极其类似，1、FileWriter和FileReader1）FileWriter
* 字符流FileWriter
* @author Administrator
publicclassFileWriterDemo{
publicstaticvoidmain(String[]args){
* 1、创建FileWriter对象，该对象在初始化时就必须明确被操作的文件
* 而且该文件将被创建到指定目录下，若该文件已经存在，则将其覆盖
* 否则，进行创建。
Filefile=newFile("files/writerFile.txt");
FileWriterfileWriter=newFileWriter(file);
//true表示不覆盖已有文件，而是直接在文件末尾续写
FileWriterfWriter=newFileWriter(file,false);
* 2、调用write方法，将字符串写入到流中
fileWriter.write("hello，你好！");
* 3、刷新流对象缓存中的数据，将数据刷新到目的地中
fileWriter.flush();
* 4、关闭资源，在关闭之前，会刷新一次流对象缓存中的数据，将其保存到目的地。
fileWriter.close();
fWriter.write("hellohello!");
fWriter.flush();
fWriter.close();
}catch(IOExceptione){
e.printStackTrace();
}}2）FileReader
* 字符流FileReader
* @author Administrator
publicclassFileReaderDemo{
publicstaticvoidmain(String[]args){
//1、创建一个文件读取流对象，和指定名称的文件相关联
要保证该文件一定存在，否则会报FileNotFoundException
Filefile=newFile("files/writerFile.txt");
FileReaderfileReader=newFileReader(file);
//2、调用read方法读取流对象，一次读一个字符，而且会自动往下读
char[]ch=newchar[100];
inttemp=0;
intcount=0;
//-1表示读到了文件末尾
while((temp=fileReader.read())!=-1){
ch[count++]=(char)
Stringfiles=newString(ch,0,count);
System.out.println(files);
}catch(IOExceptione){
e.printStackTrace();
//3、关闭资源
fileReader.close();
}catch(IOExceptione){
e.printStackTrace();
}catch(FileNotFoundExceptione){
e.printStackTrace();
}}2、BufferedWriter和BufferedReader缓冲区，是为了提高流的操作效率而产生，所以在创建缓冲区之前必须先有流对象，这种模式叫做装饰模式，比继承灵活，避免了继承的臃肿。1）BufferedWriter
* 字符流BufferedWriter
* @author Administrator
publicclassBufferedWriterDemo{
publicstaticvoidmain(String[]args){
//1、创建一个字符写入流对象
Filefile=newFile("files/writerFile.txt");
FileWriterfileWriter=newFileWriter(file,true);
//2、为了提高写入效率，加入缓冲技术
只需将需要提高效率的流对象作为参数传给缓冲区的构造函数即可
BufferedWriterbufferedWriter=newBufferedWriter(fileWriter);
//3、调用write方法，将字符串写入缓冲中
//bufferedWriter.write("汪小峰，汪小峰");
for(inti=0;i&4;i++){
bufferedWriter.write("abcde"+i);
//进行换行操作
bufferedWriter.newLine();
//bufferedWriter.flush();
//4、刷新，只要用到缓冲区，就必须进行刷新操作
bufferedWriter.flush();
//5、关闭资源
bufferedWriter.close();
fileWriter.close();
}catch(FileNotFoundExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}}2）BufferedReader
* 字符流BufferedReader
* @author Administrator
publicclassBufferedReaderDemo{
publicstaticvoidmain(String[]args){
//1、创建一个读取的流对象
Filefile=newFile("files/writerFile.txt");
FileReaderfileReader=newFileReader(file);
//2、为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲构造器
BufferedReaderbufferedReader=newBufferedReader(fileReader);
//3、调用readLine方法，读缓冲中的数据，一行一行的读入
Stringline=
while((line=bufferedReader.readLine())!=null){
System.out.println(line);
//4、关闭资源
fileReader.close();
}catch(FileNotFoundExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}}3、OutputStreamWriter和InputStreamReader转换流是字节流和字符流之间的桥梁，通常，在涉及到字符编码转换时应用。InputStreamReader:字节到字符的桥梁OutputStreamWriter:字符到字节的桥梁1）OutputStreamWriter
* 转换流OutputStreamWriter
* @author wxf
publicclassOutputStreamWriterDemo{
publicstaticvoidmain(String[]args){
//1、创建字节流对象
OutputStream outputStream = System.
//2、将字节流对象转换成字符流对象
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
//3、加入缓冲技术，提高效率
BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
//通常将以上三步简写为
BufferedWriterbufferedWriter=newBufferedWriter(newOutputStreamWriter(System.out));
//4、调用write方法，将将字符串写入缓冲中
for(inti=0;i&4;i++){
bufferedWriter.write("wangxf"+i);
bufferedWriter.newLine();
bufferedWriter.flush();
}catch(IOExceptione){
e.printStackTrace();
//6、关闭资源
bufferedWriter.close();
}catch(IOExceptione){
e.printStackTrace();
}}2）InputStreamReader
* 转换流InputStreamReader
* @author wxf
publicclassInputStreamReaderDemo{
publicstaticvoidmain(String[]args){
//1、创建字节流对象,获取键盘录入对象
InputStream inputStream = System.
//2、将字节流转换成字符流
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
//3、加入缓冲技术
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
//一般将以上三步简写为
BufferedReaderbufferedReader=newBufferedReader(newInputStreamReader(System.in));
//4、调用readLine方法读取流对象信息
Stringline=
while((line=bufferedReader.readLine())!=null){
System.out.println(line);
}catch(IOExceptione){
e.printStackTrace();
//5、关闭资源
bufferedReader.close();
}catch(IOExceptione){
e.printStackTrace();
}}通过字符流读取键盘输入的字符时，通过ctrl+z来结束。三、字节流
字节流输入输出对应关系图中蓝色的为主要的对应部分，红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。LineNumberInputStream 主要完成从流中读取数据时，会得到相应的行号，至于什么时候分行、在哪里分行是由改类主动确定的，并不是在原始中有这样一个行号。在输出部分没有对应的部分，我们完全可以自己建立一个LineNumberOutputStream，在最初写入时会有一个基准的行号，以后每次遇到换行时会在下一行添加一个行号，看起来也是可以的。好像更不入流了。PushbackInputStream 的功能是查看最后一个字节，不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。StringBufferInputStream 已经被Deprecated，本身就不应该出现在InputStream 部分，主要因为String 应该属于字符流的范围。已经被废弃了，当然输出部分也没有必要需要它了！还允许它存在只是为了保持版本的向下兼容而已。SequenceInputStream 可以认为是一个工具类，将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除，还完全不影响IO 包的结构，却让其更“纯洁”――纯洁的Decorator 模式。PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流，或者FileInputStream 写入数据，本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包！System.out 和System.out 就是PrintStream 的实例！输入字节流InputStreamInputStream 是所有的输入字节流的父类，它是一个抽象类。ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。输出字节流OutputStreamOutputStream 是所有的输出字节流的父类，它是一个抽象类。ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据，ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。1、OutputStream和InputStream1）FileOutputStream
* 字节流FileOutputStream
* @author wxf
publicclassFileOutputStreamDemo{
publicstaticvoidmain(String[]args){
//1、创建字节流对象
Filefile=newFile("files/iofiles.txt");
FileOutputStreamfileOutputStream=
fileOutputStream=newFileOutputStream(file);
}catch(FileNotFoundExceptione){
e.printStackTrace();
//2、调用write方法写入字节
byte[]b=newbyte[10];
for(inti=0;i&10;i++){
fileOutputStream.write(b,0,b.length);
}catch(IOExceptione){
e.printStackTrace();
fileOutputStream.flush();
}catch(IOExceptione){
e.printStackTrace();
//4、关闭资源
fileOutputStream.close();
}catch(IOExceptione){
e.printStackTrace();
}}2）FileInputStream
* 字节流FileInputStream
* @author wxf
publicclassFileInputStreamDemo{
publicstaticvoidmain(String[]args){
//1、创建流对象
Filefile=newFile("files/iofiles.txt");
FileInputStreamfileInputStream=
fileInputStream=newFileInputStream(file);
}catch(FileNotFoundExceptione){
e.printStackTrace();
//2、调用read方法，读入字节
byte[]bs=newbyte[10];
inttemp=0;
intcuont=0;
while((temp=fileInputStream.read())!=-1){
bs[cuont++]=(byte)
System.out.println(cuont);
Stringstring=newString(bs);
System.out.println(string);
}catch(IOExceptione){
e.printStackTrace();
//3、关闭资源
fileInputStream.close();
}catch(IOExceptione){
e.printStackTrace();
}}四、File类File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。五、RandomAccessFile类该对象并不是流体系中的一员，其封装了字节流，同时还封装了一个缓冲区（字符数组），通过内部的指针来操作字符数组中的数据。 该对象特点：该对象只能操作文件，所以构造函数接收两种类型的参数：a.字符串文件路径；b.File对象。该对象既可以对文件进行读操作，也能进行写操作，在进行对象实例化时可指定操作模式(r,rw)注意：该对象在实例化时，如果要操作的文件不存在，会自动创建；如果文件存在，写数据未指定位置，会从头开始写，即覆盖原有的内容。可以用于多线程下载或多个线程同时写数据到文件。
注：该文章是本人在搜集网上资料后总结而成，主要参考，以及
有更好的资料或者见解，希望不吝赐教。
要么读书，要么旅行，身体跟心灵，总要有一个在路上。
请关注以下微信公众号，获取更多资讯。
百战程序员_ Java1573题 QQ群：034603 掌握80%年薪20万掌握50%年薪10万 全程项目穿插, 从易到难，含17个项目视频和资料持续更新，请关注www.itbaizhan.com 国内最牛七星级团队马士兵、高淇等11位十年开发经验专...
IO流 看着字少，内容着实不少，这里开始就给诸君推荐一篇大神的博客，总结的思路清晰，鬼斧神工，哈哈，总之总结的很好。见地址: Java IO流学习总结，也是很好的入坑引言。 Java IO流学习总结Java IO流学习总结Java IO流学习总结写三次应该有人会传送过去的吧...
1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法，io的语法，虚拟机方面的语法。 1、一个&.java&源文件中是否可以包括多个类（不是内部类）？有什么限制？ 可以有多个类，但只能有一个publ...
一、流的概念和作用。 流是一种有顺序的，有起点和终点的字节集合，是对数据传输的总成或抽象。即数据在两设备之间的传输称之为流，流的本质是数据传输，根据数据传输的特性讲流抽象为各种类，方便更直观的进行数据操作。 二、IO流的分类。 根据数据处理类的不同分为：字符流和字节流。 根...
概述： 1、IO流：即Input Output的缩写。 2、特点：1）IO流用来处理设备间的数据传输。2）Java对数据的操作是通过流的方式。3）Java用于操作流的对象都在IO包中。4）流按操作数据分为两种：字节流和字符流。5）流按流向分为：输入流和输出流。 注意：流只能...
同样是下属，我忙的连睡觉的时间都没有；可是颜值高，每天可以准时下班，还可以每天花两个小时的时间化妆、卸妆。 可能与他们的差距，就在这两个小时吧～
丁香枝前香豆蔻。素衣轻起，独立桥头。当时月下百花收。静花照水，笑转星眸。 春恨落花几度秋。淡若烟缕，频见心头。残阳往事满江流。一叶扁舟，满载离愁。
文/夏青茉 我们是周末父母，过着只能周末见到孩子的生活。工作双休的时候，周六早上回去，周日下午回来。单休的时候，就只能周六晚上赶回去，周日下午赶回来。每周来回4个小时的车程，实现一次相见的约定。 像这样周六回、周日离开的周末亲子生活已经持续将近三年了，宝贝也长大到可以笑着和...
！开篇问题 ！赚钱不是手段，不是目的，而是做对了或想对了一件事的结果！ ！赚到钱的5大前提 ①想赚钱，先要对钱有概念； ②想赚钱，先要学会分解目标 ③想赚钱，先要学会花对钱 ④想赚钱，先了解最大限制 ⑤想赚钱，搞清楚到底什么在赚钱 1. 想赚钱，先要对钱有概念（概念就是“等...
今天，上午我去体检，本来想骑电动车去的，因为时间很紧张，我担心我的书读不完，所以就没有骑电动车过去，而是叫了一辆滴滴快车，这样一去一回，我有了40分钟，可以在车上看书，给同学打电话。这件事给我的体会是，时间是可以挤出来的，只要想，总会有办法。 另外一个收获就是，看到冬青昨天...博客分类：
所有的流在使用完毕时，都需要调用close方法进行关流，释放资源。由于流操作都会有异常，如果发生异常就有可能导致close方法不能被调用所以，IO异常一定要处理，close方法写在finally语句中1.InputStream : 输入字节流 方法： read()从流(关联的设备)中读一个字节 ** int read(buf):从流中读取n个字节放入缓冲区，方法会返回一个读取字节的个数 ips--&buf读到一个-1，说明读到了流的末尾 ------------------------------------------------------------------------------------------|---FileInputStream: 重载的构造函数
(String fileName)
(File file)
2.OutputStream： 输出字节流 :方法 write(int c)将一个字节写入流
(byte)cwrite(buf,offset,len)将指定字节数组的一部分写入流。 buf--&ops -------------------------------------------------------------------------------------------|---FileOutputStream: 重载的构造函数 (Strng fileName) (String fileName, boolean append) append:指定数据是否追加到文件的末尾，默认是false，覆盖原有的数据， 设置为true，将数据追加到文件的末尾3.Reader：输入字符流 int read() 读一个字符
int read(buf)
buf是char[]类型|---FileReader:
FileReader = InputStreamReader(FileInputStream) 只做了一件事：解码(父类在做)4.Writer：输出字符流 write(int c) (char)c \
write(String str) |---|---FileWriter:
FileWriter = OutputStreamWriter(FileOutputStream) 只做了一件事：编码
理解(会用)：1.装饰设计模式： 对原有的类的进行包装，对方法进行增强BufferedReader：实现缓冲的功能
创建包装流对象的时候，必须组合一个被包装的底层流
增加了一个新方法 String readLine() 读一行|--LineNumberReader: 增加了行号功能，getLineNumber() 、setLineNumber()BufferedWriter：实现了缓冲功能
new BufferedWriter(new FileWriter("1.txt");
增加了新方法
newLine() 另起一行BufferedInputStream：实现缓冲的功能BufferedOutputStream：实现缓冲的功能
2.InputStreamReader： 转换流
: 包装，实现了编码解码的功能new InputStreamReader(new FileInputStream("1.txt"));
3.使用包装流包装System.in，读键盘方便，可以读一行BufferedReader br =
new BufferedReader(new InputStreamReader(System.in));String line = br.readLine();
IO需要会写的程序： BufferedReader和BufferedWriter包装InputStream和OutputStream，读一行写一行
BufferedReader和BufferedWriter包装Reader和Writer
BufferedInputStream和BufferedOutputStream包装InputStream和OutputStream
用基础流读写，自定义数组作为缓冲区，实现拷贝
-------以下做一个总结:
io流:数据传输的中转站--&IO流--&目的地
IO流一般都是成对出现的,也就是说按照流的分向:输入流--&输出流 IO流按照操作来分: 字节流--&字符流 一.字符流基类:Reader(读)Writer(写)|-Reader |--BufferedReader:对Reader进行了包装,提供了缓冲区(8192),有ReadLine()方法
构造函数:BufferedReader(Reader r); |--InputStreamReader:转换流:将字节流转换成字符流:new InputStreamReader(System.in);
|--FileReader:读取文件的字符流,FileReader(File file) FileReader(String fileName);|-Writer |--BufferedWriter:包装流:常用的方法write(String s)、flush()刷新
newLine()换行
构造函数:BufferedWriter(Writer w); |--OutputStreamWriter:转换流: new OutputStreamWriter(System.out);
|--FileWriter:写入文件,FileWriter(File file)
FileWriter(String fileName)
FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
当append为true,将写入到文件的末尾处,当为false时,从文件开头开始写.就会覆盖原来的.默认为false
二.字节流:|-InputStream(输入流) |--FileInputStream:读取文件的字符流,和FileReader基本是一样 |--FilterInputStream:过滤流,一般不使用,只是针对了InputStream进行了包装
|--BufferedInputStream:包装类:BufferedReader(InputStream in),提供缓存功能
|-OutputStream(输出流) |--FileOutputStream:写入文件的字符流,和FileWriter基本一样 |--FilterOutputStream
|--BufferedOutputStream:包装类:BufferedWriter(OutputStream out);
三.使用IO流必须要捕获异常,原因在于我们必须要还资源(关闭流)
FileWriter fw =
fw = new FileWriter("src/1.txt");
catch(IOException e)
e.printStractTrace();
try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
四.File文件类1.构造方法:File(File parnt,String child)根据prent抽象路径名和child路径名字符串创建一个新的file实例.File(String pathname)通过将给定的路径名字来创建一个新的file实例.File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例.
2.常用方法:isFile:判断对象是否是一个标准文件isDirectory:判断对象是否为一个文件夹isAbsolute:判断是否为一个绝对路径exists:判断对象指定的文件是否存在createNewFile:根据对象的描述创建一个对象getName:获得文件名getPath:获得路径名getParent:获得文件的父级抽象路径getAbsolutepath:获得文件的绝对路径名mkdir:创建此抽象路径指定的目录,(只能在存在的文件夹下创建一个目录)mkdirs:创建此抽象路径指定的目录,包括所有必须但不存在的目录.创建多级目录(c:/a/b/c)list(FilenameFilter filter)：根据指定过滤器遍历文件夹中的所有文件，返回String[] 如果对象为标准文件，则返回null，如果对象是一个空文件夹，则返回空数组。length为0 FilenameFilter是一个接口，只有一个方法accept，我们需要实现接口的accept方法。 实现类是给list方法自动调用的 方法的参数是list方法传给我们的，返回的结果也是给list方法去用。listFiles：和list基本一样，返回值类型不一样，返回File[]。常用案例：遍历目录下所有的文件和文件夹
拷贝一个文件夹
五:RandomAccessFile 文件流,可以读写1.RandomAccessFile(File file,String mode)、RandomAccessFile(String fileName,String mode) mode:常用的: r,只读 rw读写2.有很多read和write方法. seek方法,指定从那个位置开始读seek(0) ,从原有的位置覆盖掉skipBytes(int n)：跳过多少个字节
六:PrintStream、PrintWriter打印流有一个特殊的方法print可以实现打印write方法是直接将字节和字符写出去print：首先调用对象的toString方法转成字符串(如果是基本数据类型，会先自动装箱) 再将字符串编码成字节数组，调用write方法写出去
七:SequenceInputStream序列流可以将多个字节流组合起来构造方法：SequenceInputStream(Enumeration&? extends InputStream& e)
//Enumeration可以通过Vector来获得，如果用的是ArrayList，如何获得呢？
SequenceInputStream(InputStream in1,InputStream in2)
八:ObjectInputStream、ObjectOutputStream操作对象的字节流一般成对出现使用writeObject方法写入的对象，只能由readObject方法读出来操作的对象必须实现java.io.Serializable序列化接口，该对象才可以被序列化和反序列化。序列化: Java中规定的一种保存对象的数据格式
九:DataInputStream、DataOutputStream操作基本数据类型，格式化数据readInt、writeInt等方法。writeInt写入一个整数，文件大小为4字节。证明就是把基本数据类型对应的字节写出去了，没有丢失精度
十:ByteArrayInputStream、ByteArrayOutputStream对Byte数组进行读写的字节流，针对内存进行读写源和目的地都是内存，一般用于对内存中的数据进行处理。
十一:PipedInputStream、PipedOutputStream管道流1、输入管道流构造方法：PipedInputStream(PipedOutputStream pos)实现拼接也可以通过connect(PipedOutputStream pos)方法进行拼接
2、输出管道流构造方法：PipedOutputStream(PipedInputStream pis)实现拼接也可以通过connect(PipedInputStream pis)方法进行拼接
--Test:序列化与反序列化..
package com.java.kudy_S
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.IOE
import java.io.ObjectOutputS
import java.io.S
import java.util.ArrayL
import java.io.ObjectInputS
import java.io.FileInputS
序列化与反序列化的过程
public class Test {
public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
Student s1 = new Student("张三",18);
Student s2 = new Student("王五",19);
Student s3 = new Student("李四",20);
Student s4 = new Student("大毛",21);
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
ArrayList&Student& al = new ArrayList&Student&();
al.add(s1);
al.add(s2);
al.add(s3);
al.add(s4);
oos.writeObject(al);
oos.close();//关闭流
//首先我们把内容放到一个集合里面去
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("f:/a.txt"));
ArrayList&Student& al = (ArrayList&Student&)ois.readObject();
for(Student s :al)
System.out.println(s);
ois.close();
//必须要实现一个类
class Student implements Serializable
Student(){}
Student(String name,int age)
this.name =
this.age =
public String toString()
return name+"@"+
浏览: 6831 次
来自: 广州
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'