System.out.println（fileArr[i].getAbsolutePath（））;
}
}
}
}
1.输入流和输出流（按照流的流向来分,注意选择参照对象）
输入流:
只能从中读取数据，而不能向其写入数据
输出流:
只能向其写入数据，而不能从中读取数据
2.字节流与字符流（按操作数据单元不同）
字节流与字符流用法一样，只是操作数据单元不同:
一个是字节（8位），一个是字符（16位）
字节流以InputStream与OutputStream为基类
字符流以Reader与Writer为基类
•流的概念模型
Java的IO流共有40多个类，但这40多个类都是从如下4个抽象基类派生的
1.InputStream/Reader:
所有输入流的基类，前一个是字节输入流，后一个是字符输入流
2.OutputStream/Writer:
所有输出流的基类，前一个是字节输出流，后一个是字符输出流
FileInputStream
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.IOException;
importjava.io.InputStream;
publicclassFileIsDemo{
publicstaticvoidmain（String[]args）{
FileIsDemofid=newFileIsDemo（）;
fid.readInfo（）;
}
publicvoidreadInfo（）{
//创建一个文件对象
Filefile=newFile（"D:
/GZT/test/test/text.txt"）;
InputStreamis=null;
try{
is=newFileInputStream（file）;
//is=newFileInputStream（"D:
/GZT/test/test/text.txt"）;
//读取下一个字节，如果读到流（is）的结尾返回-1
intdata=0;
//有小括号先算小括号里面的
//while（（data=is.read（））!
=-1）{
////中文会被读成两截，产生乱码
//System.out.println（（char）data）;
//}
byte[]bs=newbyte[100];
//将读取到的内容放到bs中，从bs0位置开始存放，存放长度是100
//这里会因为文件本身内容长度不足以填满bs时，其后会议空格填充
//data读取到的文本字节数据个数
//bs内存中，在读文件内容的时候，先读一个字节数据到bs中，
//bs没有满，文件也没有读完，接着读第二个放到bs中，bs没有满
//文件也没有读完，一次类推，要么bs读满，要么读到文件结束
//可以操作bs获取数据
while（（data=is.read（bs,0,bs.length））!
=-1）{
System.out.println（"======"）;
//中文也会被读成两截，产生乱码
System.out.println（newString（bs,0,data））;
}
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}finally{
//关闭流
try{
if（null!
=is）{
is.close（）;
}
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
}
FileOutputStream
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.OutputStream;
publicclassFileOsDemo{
publicstaticvoidmain（String[]args）{
FileOsDemofod=newFileOsDemo（）;
fod.outputInfo（）;
}
publicvoidoutputInfo（）{
OutputStreamos=null;
try{
//输出流的初始化
//默认是覆盖的写入，当后面传入的参数是true时，便是追加的写入
os=newFileOutputStream（"D:
/GZT/test/test/text.txt",false）;
Stringinfo="韩国部署萨德是不道德的韩国部署萨德是不道德的";
//os.write（97）;//a
byte[]bs=info.getBytes（）;
//一个中文3个字节
os.write（bs）;//os.write（bs,0,bs.length）;
os.write（bs,0,6）;//写入整个字节数组
//从第二个位置开始，写入长度为3
//os.write（"acbdef".getBytes（）,2,3）;
//os.flush（）;
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}finally{
if（null!
=os）{
try{
os.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
}
}
文件复制
importjava.io.Closeable;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
publicclassFileCopyDemo{
//读文件的路径
privateStringiPath="D:
/GZT/test/test/text.txt";
//写文件的路径
privateStringoPath="D:
/GZT/test/test/text1.txt";
publicstaticvoidmain（String[]args）{
FileCopyDemofcd=newFileCopyDemo（）;
fcd.copyFile（）;
}
/**
*
*@parampath
*@returntrue表示文件存在，false文件不存在
*/
publicbooleanexistFile（Stringpath）{
Filefile=newFile（path）;
//先判读目录存在不存在，如果不存在，则创建，否则不管
if（!
file.getParentFile（）.exists（））{
file.getParentFile（）.mkdirs（）;
}
//判断文件存在不存在，如果不存在，则创建
if（!
file.exists（））{
try{
//如果不存在，并创建成功返回true，否则返回false
returnfile.createNewFile（）;
}catch（IOExceptione）{
returnfalse;
}
}
returntrue;
}
publicbooleanfileError（）{
//判断读写文件是否都存在，如果有一个不存在，则执行return结束方法
if（!
existFile（iPath））{
System.out.println（"读的文件不存在，请检查后在执行"）;
returnfalse;
}
if（!
existFile（oPath））{
System.out.println（"写的文件不存在，请检查后在执行"）;
returnfalse;
}
returntrue;
}
publicvoidcopyFile（）{
//输入流读输出流写
InputStreamis=null;
OutputStreamos=null;
if（!
fileError（））{
return;
}
try{
is=newFileInputStream（iPath）;
os=newFileOutputStream（oPath）;
byte[]b=newbyte[100];
intdata=0;
while（（data=is.read（b））!
=-1）{
os.write（b,0,data）;
}
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}finally{
//FileOutputStreamextendsOutputStreamimplementsCloseable
//Closeable中有close方法，
//Closeablecl=os;
//cl.close（）;
closeStream（os）;
closeStream（is）;
}
}
/**
*关闭流
*
*@paramstream
*/
publicvoidcloseStream（Closeablestream）{
try{
stream.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
BufferedInputStream
importjava.io.BufferedInputStream;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.IOException;
importjava.io.InputStream;
publicclassBisDemo{
privatestaticStringpath="D:
/GZT/test/test/text.txt";
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
bufferIs（）;
}
privatestaticvoidbufferIs（）{
FileInputStreamfis=null;
InputStreamis=null;
try{
fis=newFileInputStream（path）;
is=newBufferedInputStream（fis）;
byte[]b=newbyte[100];
intdata=0;
//关于flush方法
//刷新缓冲区缓冲区在没有满的情况下他还在内存中，我们是无法操作其中的数据
//当缓冲区满了之后，我们便可以通过变量访问到他
while（（data=is.read（b））!
=-1）{
System.out.println（newString（b,0,data））;
}
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}finally{
if（null!
=is）{
try{
is.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
}
}
BufferedOutputStream
importjava.io.BufferedOutputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
publicclassBufOsDemo{
privatestaticStringpath="D:
/GZT/test/test/text.txt";
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
bufOs（）;
}
privatestaticvoidbufOs（）{
BufferedOutputStreambos=null;
try{
bos=newBufferedOutputStream（newFileOutputStream（path,true））;
Stringinfo="**韩国滚蛋了";
bos.write（info.getBytes（））;
//如果发现内容没有写全，那么就调用flush方法
//刷新缓冲区
bos.flush（）;
}catch（FileNotFoundExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}finally{
if（null!
=bos）{
try{
bos.close（）;
}catch（IOExceptione）{
//TODOAuto-generatedcatchblock
e.printStackTrace（）;
}
}
}
}
}
FileReader
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.Reader;
/**
*
*InputStreamOutputStream
*FileInputStreamFileOutputStream
*BufferedInputStreamBufferedOutputStream
*
*ReaderWriter
*FileReaderFileWriter
*BufferedReaderBufferedWriter
*
*/
publicclassFileReaderDemo{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
fileReader（）;
}
privatestaticvoidfileReader（）{
//IputStreamis=newFileInputStream（""）;
Readerreader=null;
try{
reader=newFi
升级会员 