马士兵 JAVA视频教程第08章流IO.docx
《马士兵 JAVA视频教程第08章流IO.docx》由会员分享，可在线阅读，更多相关《马士兵 JAVA视频教程第08章流IO.docx（17页珍藏版）》请在冰豆网上搜索。
马士兵JAVA视频教程第08章流IO
第八章流
1Java流式输入/输出原理
2Java流类的分类
3输入,输出流类
4常见的节点流（常见：
文件流，分为：
字符,字节流/输入,输出流）和处理流（常见：
缓冲流，分为）
4.1文件流
4.2缓冲流
5数据流
6转换流
7Print流
8Object流
2010年3月31日星期三,19:
54:
28–2010年4月2日星期五20:
00:
27
1.java流式输入输出流原理文件（桶）-流（管道）-程序
2.
java输入输出流分类（输入输出相对于程序来说的,而不是文件）
Java.io包中定义了多个流类型（类或者抽象类）来实现输入/输出功能：
可以不
按数据流的方向不同分为输入流和输出流
按处理数据单位不同分为字节流和字符流
按功能不同分为节点流和处理流
J2SDK所提供的所有流类型位于包Java,io内都分别继承自以下四中抽象流类型。
字节流（Stream）
字符流（两个字节）
输入流
InputStream
Reader
输出流
OutputStream
Writer
3.输入/输出流类4个
1InputStream继承自InputStream的流都是用于向程序中输入数据,且数据的单位为字节（8bit），下图深色为节点流，浅色为处理流
InputStream的基本方法
2OutputStream继承自outputStream的流都是用于程序中输入数据,且数据的单位为字节（8bit），下图深色为节点流，浅色为处理流
OutputStream的基本方法
3Reader继承自Reader的流都是用于向程序输入数据，且数据的单位为字节（16bit），下图深色为节点流，浅色为处理流
Reader的基本用法
4Writer继承自Writer的流都是用于程序中输入数据，且数据的单位为字节（16bit），下图深色为节点流，浅色为处理流
writer的基本用法
4.常见节点流/处理流
4.1节点流类型（直接读取写入..不经过处理）
4.1.1常见节点流：
文件流
例子：
IO\TestFileInputStream.java字节流按一个字节一个字节读取文件
importjava.io.*;
publicclassTestFileInputStream{
publicstaticvoidmain（String[]args）{
intb=0;
FileInputStreamin=null;
try{
in=newFileInputStream（"F:
\\MyWorkspace\\Java\\IO\\TestFileInputStream.java"）;
}catch（FileNotFoundExceptione）{
System.out.println（"找不到指定文件"）;
System.exit（-1）;
}
try{//读数据
longnum=0;
while（（b=in.read（））!
=-1）{//读一个字节到变量b，b=-1表示读取完成
System.out.print（（char）b）;
num++;//计数
}
in.close（）;
System.out.println（）;
System.out.println（"共读取了"+num+"个字节"）;
}catch（IOExceptione1）{
System.out.println（"文件读取错误"）;System.exit（-1）;
}
}
}
IO\TestFileOutputStream.java字节流复制文件
importjava.io.*;
publicclassTestFileOutputStream{
publicstaticvoidmain（String[]args）{
intb=0;
FileInputStreamin=null;//声明in为文件输入流（管道）
FileOutputStreamout=null;//声明out为文件输流（管道）
try{
in=newFileInputStream（"F:
/MyWorkspace/Java/IO/TestFileOutputStream.java"）;
out=newFileOutputStream（"F:
/MyWorkspace/Java/IO/copyTestFileOutputStream.java"）;
while（（b=in.read（））!
=-1）{
out.write（b）;
}
in.close（）;
out.close（）;
}catch（FileNotFoundExceptione2）{
System.out.println（"找不到指定文件"）;System.exit（-1）;
}catch（IOExceptione1）{
System.out.println（"文件复制错误"）;System.exit（-1）;
}
System.out.println（"文件已复制"）;
}
}
IO\TestFileReader.java字符流按一个字符一个读取文件
importjava.io.*;
publicclassTestFileReader{
publicstaticvoidmain（String[]args）{
FileReaderfr=null;
intc=0;
try{
fr=newFileReader（"d:
\\share\\java\\io\\TestFileReader.java"）;
intln=0;
while（（c=fr.read（））!
=-1）{
//charch=（char）fr.read（）;
System.out.print（（char）c）;
//if（++ln>=100）{System.out.println（）;ln=0;}
}
fr.close（）;
}catch（FileNotFoundExceptione）{
System.out.println（"找不到指定文件"）;
}catch（IOExceptione）{
System.out.println（"文件读取错误"）;
}
}
}
IO\TestFileWriter.java字符流输出大多国家的数文字
importjava.io.*;
publicclassTestFileWriter{
publicstaticvoidmain（String[]args）{
FileWriterfw=null;
try{
fw=newFileWriter（"F:
\\MyWorkspace\\Java\\IO\\unicode.txt"）;
for（intc=0;c<=50000;c++）{
fw.write（c）;
}
fw.close（）;
}catch（IOExceptione1）{
e1.printStackTrace（）;
System.out.println（"文件写入错误"）;
System.exit（-1）;
}
}
}
IO\TestFileWriter2.java字符流复制文件并且每个字符后面多输出一个“|”字符
importjava.io.*;
publicclassTestFileWriter2{
publicstaticvoidmain（String[]args）{
intb=0;
FileReaderfn=null;
FileWriterfw=null;
try{
fn=newFileReader（"F:
\\MyWorkspace\\Java\\IO\\TestFileWriter2.java"）;
fw=newFileWriter（"F:
\\MyWorkspace\\Java\\IO\\copyTestFileWriter2.txt"）;
while（（b=fn.read（））!
=-1）{
fw.write（“|”）;
fw.write（b）;
}
fn.close（）;
fw.close（）;
}catch（IOExceptione1）{
e1.printStackTrace（）;
System.out.println（"文件写入错误"）;
System.exit（-1）;
}
}
}
4.2处理流（经过处理的流）
4.2.1常见处理流：
缓冲流
IO\TestBufferStream1.java
importjava.io.*;
publicclassTestBufferStream1{
publicstaticvoidmain（String[]args）{
try{
FileInputStreamfis=
newFileInputStream（"F:
\\MyWorkspace\\Java\\IO\\TestBufferStream1.java"）;
BufferedInputStreambis=
newBufferedInputStream（fis）;
intc=0;
System.out.println（bis.read（））;
System.out.println（bis.read（））;
bis.mark（100）;//从100号往外读
for（inti=0;i<=10&&（c=bis.read（））!
=-1;i++）{
System.out.print（（char）c+""）;
}
System.out.println（）;
bis.reset（）;//回到标记点
for（inti=0;i<=10&&（c=bis.read（））!
=-1;i++）{
System.out.print（（char）c+""）;
}
bis.close（）;
}catch（IOExceptione）{e.printStackTrace（）;}
}
}
IO/TestBufferStream2.java带缓冲区的输入输出流（能读一行）
importjava.io.*;
publicclassTestBufferStream2{
publicstaticvoidmain（String[]args）{
try{
BufferedWriterbw=newBufferedWriter（newFileWriter（"d:
\\share\\java\\dat2.txt"））;
BufferedReaderbr=newBufferedReader（
newFileReader（"d:
\\share\\java\\dat2.txt"））;
Strings=null;
for（inti=1;i<=100;i++）{
s=String.valueOf（Math.random（））;
bw.write（s）;
bw.newLine（）;
}
bw.flush（）;//全部取出缓冲区数据
while（（s=br.readLine（））!
=null）{//读一行
System.out.println（s）;
}
bw.close（）;
br.close（）;
}catch（IOExceptione）{e.printStackTrace（）;}
}
}
5.转换流
InputStreamReader和OutputStreamWriter用于与字节数据到字符数据之间转换。
InputStreamReader需和InputStream“套接”。
InputStream转换成Reader
OutputStreamWriter需和OutputStream“套接”。
OutputStream转换成Writer
转换流在构造时可以指定起编码集合，例如
InputStreamisr=newInputStreamReader（System.in,“ISO08859_1”）
例子IO\TestTransForm1.java
IO\TestTransForm2.java
importjava.io.*;
publicclassTestTransForm2{
publicstaticvoidmain（Stringargs[]）{
InputStreamReaderisr=
newInputStreamReader（System.in）;//接受键盘输入
BufferedReaderbr=newBufferedReader（isr）;
Strings=null;
try{
s=br.readLine（）;//读一行
while（s!
=null）{
if（s.equalsIgnoreCase（"exit"））break;
System.out.println（s.toUpperCase（））;
s=br.readLine（）;
}
br.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}//阻塞
6.数据流
DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，它属于处理流，需要分别“套接”在InputStream和OutputStream类型的节点流上。
DataInputStream和DataOutputStream踢狗了可以存取与机器无关的Java原始类型数据（如:
int,double等）的方法
DataInputStream和DataOutputStream的构造方法：
DataInputStream（InputStreamin）
DataOutputStream（OutputStreamout）
例子
7.Print流
例子1
importjava.io.*;
publicclassTestPrintStream1{
publicstaticvoidmain（String[]args）{
PrintStreamps=null;
try{
FileOutputStreamfos=
newFileOutputStream（"d:
\\bak\\log.dat"）;
ps=newPrintStream（fos）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
if（ps!
=null）{
System.setOut（ps）;//设置输出窗口..
}
intln=0;
for（charc=0;c<=60000;c++）{
System.out.print（c+""）;
if（ln++>=100）{System.out.println（）;ln=0;}
}
}
}
例子3
importjava.util.*;
importjava.io.*;
publicclassTestPrintStream3{
publicstaticvoidmain（String[]args）{
Strings=null;
BufferedReaderbr=newBufferedReader（
newInputStreamReader（System.in））;
try{
FileWriterfw=newFileWriter
（"d:
\\bak\\logfile.log",true）;//Log4J
PrintWriterlog=newPrintWriter（fw）;
while（（s=br.readLine（））!
=null）{
if（s.equalsIgnoreCase（"exit"））break;
System.out.println（s.toUpperCase（））;
log.println（"-----"）;
log.println（s.toUpperCase（））;
log.flush（）;
}
log.println（"==="+newDate（）+"==="）;
log.flush（）;
log.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
8.Object流直接将Object写入或读出
transient关键字透明的
serializable接口可序列化
externalizable接口控制序列化
importjava.io.*;
publicclassTestObjectIO{
publicstaticvoidmain（Stringargs[]）throwsException{
Tt=newT（）;
t.k=8;
FileOutputStreamfos=newFileOutputStream（"d:
/share/java/io/testobjectio.dat"）;
ObjectOutputStreamoos=newObjectOutputStream（fos）;
oos.writeObject（t）;
oos.flush（）;
oos.close（）;
FileInputStreamfis=newFileInputStream（"d:
/share/java/io/testobjectio.dat"）;
ObjectInputStreamois=newObjectInputStream（fis）;
TtReaded=（T）ois.readObject（）;
System.out.println（tReaded.i+""+tReaded.j+""+tReaded.d+""+tReaded.k）;
}
}
classT
implementsSerializable
{
inti=10;
intj=9;
doubled=2.3;
transientintk=15;
}
升级会员 