java读取文件InpitStream基础入门.docx
《java读取文件InpitStream基础入门.docx》由会员分享，可在线阅读，更多相关《java读取文件InpitStream基础入门.docx（26页珍藏版）》请在冰豆网上搜索。
java读取文件InpitStream基础入门
packagecn.itcast.buffered;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
练习：
使用缓冲输入输出字节流拷贝一个图片。
*/
publicclassCopyImage{
publicstaticvoidmain（String[]args）throwsIOException{
//找到目标文件
FileinFile=newFile（"F:
\\美女\\1.jpg"）;
FileoutFile=newFile（"E:
\\1.jpg"）;
//建立数据输入输出通道
FileInputStreamfileInputStream=newFileInputStream（inFile）;
FileOutputStreamfileOutputStream=newFileOutputStream（outFile）;
//建立缓冲输入输出流
BufferedInputStreambufferedInputStream=newBufferedInputStream（fileInputStream）;
BufferedOutputStreambufferedOutputStream=newBufferedOutputStream（fileOutputStream）;
//边读边写
intcontent=0;
//intlength=bufferedInputStream.read（buf）;如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
while（（content=bufferedInputStream.read（））!
=-1）{//如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
bufferedOutputStream.write（content）;
//bufferedOutputStream.flush（）;
}
//关闭资源
bufferedInputStream.close（）;
bufferedOutputStream.close（）;
}
}
packagecn.itcast.buffered;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
我们清楚读取文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
这时候sun给我们提供了一个------缓冲输入字节流对象,让我们可以更高效率读取文件。
输入字节流体系：
----|InputStream输入字节流的基类。
抽象
----------|FileInputStream读取文件数据的输入字节流
----------|BufferedInputStream缓冲输入字节流缓冲输入字节流的出现主要是为了提高读取文件数据的效率。
其实该类内部只不过是维护了一个8kb的字节数组而已。
注意：
凡是缓冲流都不具备读写文件的能力。
使用BufferedInputStream的步骤:
1.找到目标文件。
2.建立数据的输入通道
3.建立缓冲输入字节流流
4.关闭资源
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）throwsIOException{
readTest2（）;
}
publicstaticvoidreadTest2（）throwsIOException{
//找到目标文件
Filefile=newFile（"F:
\\a.txt"）;
FileInputStreamfileInputStream=newFileInputStream（file）;
BufferedInputStreambufferedInputStream=newBufferedInputStream（fileInputStream）;
bufferedInputStream.read（）;
FileOutputStreamfileOutputStream=newFileOutputStream（file）;
BufferedOutputStreambufferedOutputStream=newBufferedOutputStream（fileOutputStream）;
fileOutputStream.write（null）;
//读取文件数据
intcontent=0;
//疑问二：
BufferedInputStream出现的目的是了提高读取文件的效率，但是BufferedInputStream的read方法每次读取一个字节的数据
//而FileInputStreram每次也是读取一个字节的数据，那么BufferedInputStream效率高从何而来？
while（（content=fileInputStream.read（））!
=-1）{
System.out.print（（char）content）;
}
//关闭资源
bufferedInputStream.close（）;//调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
}
//读取文件的时候我们都是使用缓冲数组读取。
效率会更加高
publicstaticvoidreadTest（）throwsIOException{
Filefile=newFile（"F:
\\a.txt"）;
//建立数组通道
FileInputStreamfileInputStream=newFileInputStream（file）;
//建立缓冲数组读取数据
byte[]buf=newbyte[1024*8];
intlength=0;
while（（length=fileInputStream.read（buf））!
=-1）{
System.out.print（newString（buf,0,length））;
}
//关闭资源
fileInputStream.close（）;
}
}
packagecn.itcast.buffered;
importjava.io.BufferedOutputStream;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
输出字节流
--------|OutputStream所有输出字节流的基类抽象类
------------|FileOutputStream向文件输出数据的输出字节流
------------|Bufferedoutputstream缓冲输出字节流BufferedOutputStream出现的目的是为了提高写数据的效率。
内部也是维护了一个8kb的字节数组而已。
使用BufferedOutputStream的步骤：
1.找到目标文件
2.建立数据的输出通道
BufferedOutputStream要注意的细节
1.使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
2.使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
调用flush方法或者是close方法、或者是内部维护的字节数组已经填满数据的时候。
*/
publicclassDemo2{
publicstaticvoidmain（String[]args）throwsIOException{
//找到目标文件
Filefile=newFile（"F:
\\a.txt"）;
//建立数据的输出通道
FileOutputStreamfileOutputStream=newFileOutputStream（file）;
//建立缓冲输出字节流对象
BufferedOutputStreambufferedOutputStream=newBufferedOutputStream（fileOutputStream）;
//把数据写出
bufferedOutputStream.write（"helloworld".getBytes（））;
//把缓冲数组中内部的数据写到硬盘上面。
//bufferedOutputStream.flush（）;
bufferedOutputStream.close（）;
}
}
packagecn.itcast.exception;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjavax.management.RuntimeErrorException;
/*
IO异常的处理
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）{
//readTest（）;
copyImage（）;
}
//拷贝图片
publicstaticvoidcopyImage（）{
FileInputStreamfileInputStream=null;
FileOutputStreamfileOutputStream=null;
try{
//找到目标文件
FileinFile=newFile（"F:
\\美女\\1.jpg"）;
FileoutFile=newFile（"E:
\\1.jpg"）;
//建立输入输出通道
fileInputStream=newFileInputStream（inFile）;
fileOutputStream=newFileOutputStream（outFile）;
//建立缓冲数组，边读边写
byte[]buf=newbyte[1024];
intlength=0;
while（（length=fileInputStream.read（buf））!
=-1）{
fileOutputStream.write（buf,0,length）;
}
}catch（IOExceptione）{
System.out.println（"拷贝图片出错..."）;
thrownewRuntimeException（e）;
}finally{
//关闭资源
try{
if（fileOutputStream!
=null）{
fileOutputStream.close（）;
System.out.println（"关闭输出流对象成功..."）;
}
}catch（IOExceptione）{
System.out.println（"关闭输出流资源失败..."）;
thrownewRuntimeException（e）;
}finally{
if（fileInputStream!
=null）{
try{
fileInputStream.close（）;
System.out.println（"关闭输入流对象成功..."）;
}catch（IOExceptione）{
System.out.println（"关闭输入流对象失败..."）;
thrownewRuntimeException（e）;
}
}
}
}
}
publicstaticvoidreadTest（）{
FileInputStreamfileInputStream=null;
try{
//找到目标文件
Filefile=newFile（"F:
\\aaaaa.txt"）;
//建立数据输入通道
fileInputStream=newFileInputStream（file）;
//建立缓冲数组读取数据
byte[]buf=newbyte[1024];
intlength=0;
while（（length=fileInputStream.read（buf））!
=-1）{
System.out.print（newString（buf,0,length））;
}
}catch（IOExceptione）{
/*
*//处理的代码...首先你要阻止后面的代码执行,而且要需要通知调用者这里出错了...thrownew
*RuntimeException（e）;
*//把IOException传递给RuntimeException包装一层，然后再抛出，这样子做的目的是
*为了让调用者使用变得更加灵活。
*/
System.out.println（"读取文件资源出错...."）;
thrownewRuntimeException（e）;
}finally{
try{
if（fileInputStream!
=null）{
fileInputStream.close（）;
System.out.println（"关闭资源成功..."）;
}
}catch（IOExceptione）{
System.out.println（"关闭资源失败..."）;
thrownewRuntimeException（e）;
}
}
}
}
packagecn.itcast.input;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.IOException;
/*
File类:
用于描述一个文件或者文件夹的。
通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。
IO流（InputOutput）
IO流解决问题：
解决设备与设备之间的数据传输问题。
内存--->硬盘硬盘--->内存
IO流技术：
IO流分类：
如果是按照数据的流向划分：
输入流
输出流
如果按照处理的单位划分：
字节流:
字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。
字符流：
字符流读取的数据是以字符为单位的。
字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能识别的字符。
字符流=字节流+解码
输入字节流：
--------|InputStream所有输入字节流的基类抽象类
------------|FileInputStream读取文件数据的输入字节流
使用FileInputStream读取文件数据的步骤：
1.找到目标文件
2.建立数据的输入通道。
3.读取文件中的数据。
4.关闭资源.
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）throwsIOException{
readTest4（）;
}
//方式4：
使用缓冲数组配合循环一起读取。
28
publicstaticvoidreadTest4（）throwsIOException{
longstartTime=System.currentTimeMillis（）;
//找到目标文件
Filefile=newFile（"F:
\\美女\\1.jpg"）;
//建立数据的输入通道
FileInputStreamfileInputStream=newFileInputStream（file）;
//建立缓冲数组配合循环读取文件的数据。
intlength=0;//保存每次读取到的字节个数。
byte[]buf=newbyte[1024];//存储读取到的数据缓冲数组的长度一般是1024的倍数，因为与计算机的处理单位。
理论上缓冲数组越大，效率越高
while（（length=fileInputStream.read（buf））!
=-1）{//read方法如果读取到了文件的末尾，那么会返回-1表示。
System.out.print（newString（buf,0,length））;
}
//关闭资源
fileInputStream.close（）;
longendTime=System.currentTimeMillis（）;
System.out.println（"读取的时间是：
"+（endTime-startTime））;//446
}
//方式3：
使用缓冲数组读取。
缺点：
无法读取完整一个文件的数据。
12G
publicstaticvoidreadTest3（）throwsIOException{
//找到目标文件
Filefile=newFile（"F:
\\a.txt"）;
//建立数据的输入通道
FileInputStreamfileInputStream=newFileInputStream（file）;
//建立缓冲字节数组，读取文件的数据。
byte[]buf=newbyte[1024];//相当于超市里面的购物车。
intlength=fileInputStream.read（buf）;//如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
System.out.println（"length:
"+length）;
//使用字节数组构建字符串
Stringcontent=newString（buf,0,length）;
System.out.println（"内容：
"+content）;
//关闭资源
fileInputStream.close（）;
}
//方式2：
使用循环读取文件的数据
publicstaticvoidreadTest2（）throwsIOException{
longstartTime=System.currentTimeMillis（）;
//找到目标文件
Filefile=newFile（"F:
\\美女\\1.jpg"）;
//建立数据的输入通道
FileInputStreamfileInputStream=newFileInputStream（file）;
//读取文件的数据
intcontent=0;//声明该变量用于存储读取到的数据
while（（content=fileInputStream.read（））!
=-1）{
System.out.print（（char）content）;
}
//关闭资源
fileInputStream.close（）;
longendTime=System.currentTimeMillis（）;
System.out.println（"读取的时间是：
"+（endTime-startTime））;//446
}
//读取的方式一缺陷：
无法读取完整一个文件的数据.
publicstaticvoidreadTest1（）throwsIOException{
//1.找到目标文件
Filefile=newFile（"F:
\\a.txt"）;
//建立数据的输入通道。
FileInputStreamfileInputStream=newFileInputStream（file）;
//读取文件中的数据
intcontent=fileInputStream.read（）;//read（）读取一个字节的数据，把读取的数据返回。
System.out.println（"读到的内容是：
"+（char）content）;
//关闭资源实际上就是释放资源。
fileInputStream.
升级会员 