IO异常总结.docx
《IO异常总结.docx》由会员分享，可在线阅读，更多相关《IO异常总结.docx（24页珍藏版）》请在冰豆网上搜索。
IO异常总结
异常总结
1：
异常（理解）
（1）异常：
就是程序出现的不正常情况。
（2）异常体系：
Throwable
|--Error严重的问题，是处理不了的。
要改正代码的。
|--Exception
非RuntimeException的，是需要处理的。
编译期异常。
|--RuntimeException不需要处理的，是需要改代码的。
运行期异常。
举例：
Error:
地震，海啸。
Exception:
感冒了，头疼。
注意：
每种体系的子类都是以父亲的名称作为后缀。
XxxError
XxxException
（3）java虚拟机的默认处理方式
把异常的类名，原因，位置等信息显示在控制台。
一旦有异常发生，其后的代码不能继续执行。
（4）异常的解决方案：
A:
自己处理
基本格式：
try{
可能发生异常的代码;
}catch（异常类名变量名）{
异常的处理代码;
}finally{
释放资源的代码;
}
注意：
一旦有一次发生，就会立马执行catch里面的代码。
变形格式：
try...catch
try...catch...catch
try...catch...catch...finally
try...finally
JDK7针对多个catch进行了优化：
catch（异常1|异常2|异常3...变量）{}
注意：
这些异常必须是平级关系。
和try...catch...catch的不同点是
JDK7的这种方案是必须平级关系，不能有子父关系。
而try...catch...catch父亲放最后是可以的。
B:
抛出处理
用throws关键字在方法上声明（抛出）。
C:
到底使用谁?
a:
能自己处理的尽量自己处理。
（建议用try...catch）
b:
实在不行，你先抛了在说。
上就业班我们对异常是进行统一处理的。
看到问题，点击鼠标。
可能出现的面试题:
（5）finally的特点及面试题
A:
特点
里面的代码永远会执行。
除非前面退出jvm。
c
B:
面试题
a:
请说说final,finally,finalize的区别?
b:
finally里面的代码永远会执行吗?
c:
假如在catch里面有ruturn,finally里面的代码还能被执行吗?
如果能,请问是在return前,还是在return后?
如果你能说在中间，就更好了。
（6）Exception和RuntimeException的区别?
A:
Exception编译时期异常，必须处理的。
如果在方法上，throws了该类型的异常，将来调用者必须处理。
如果在方法内部，throw了该类型的异常，必须在方法上throws该异常。
B:
RuntimeException运行时期异常，是不需要处理的。
要改代码的。
如果在方法上，throws了该类型的异常，不需要处理。
如果在方法内部，throw了该类型的异常，方法上可以throws该异常，也可以不throws该异常。
（7）throw和throws的用法和区别?
A:
throw
用法：
用在方法内部，后面跟的是异常对象名称。
区别：
用throw抛出了编译时期异常，方法上面必须用throws抛出。
用throw抛出了运行时期异常，方法上面可以不用throws抛出。
B:
throws
用法：
用在方法声明上，后面跟的是异常类名。
区别：
用throws在方法上声明了异常，内部可以没有throw
File类总结
1.File类（掌握）
（1）概述
因为数据在硬盘上最常见的方式，就是文件。
而文件本身有很多的属性，比如说：
文件大小，是否可读，是否隐藏。
那么java为了方便我们对文件进行操作，就提供了File类供我们使用。
File：
既可以表示文件，也可以表示（目录）文件夹。
（2）构造方法：
File（Stringpathname）:
根据指定的路径创建File对象。
File（Stringparent,Stringchild）:
根据指定的父文件夹和子文件或者文件夹创建File对象
File（Fileparent,Stringchild）:
根据指定的父文件夹对象和子文件或者文件夹创建File对象
（3）成员方法：
a：
创建功能：
创建文件：
publicbooleancreateNewFile（）如果指定的文件不存在，就创建。
如果存在，就不创建
创建文件夹：
publicbooleanmkdir（）创建指定的目录，如果存在，就不创建
publicbooleanmkdirs（）创建指定的目录，如果存在，就不创建。
这个时候，如果父目录不存在，它也会自动创建
注意：
你要创建什么，自己最清楚。
也就是，你要调用哪个方法，你自己必须明白
因为如果你不明白，就会有问题。
绝对路径:
以盘符开始的路径
相对路径：
不以盘符开始的路径
b：
删除功能：
publicbooleandelete（）:
既可以删除文件，也可以删除文件夹，取决于使用的对象
注意：
A：
如果你删除的目录下还有内容，那么，必须先把使用内容删除完毕后，在删除目录
B：
java语言的删除不走回收站
c：
判断功能：
（自己补齐功能方法名和返回值以及参数列表）
判断file对象是否存在
判断file对象是否是文件
判断file对象是否是文件夹
判断file对象是否是绝对路径
判断file对象是否可读
判断file对象是否可写
判断file对象是否隐藏
d：
获取功能：
（自己补齐功能方法名和返回值以及参数列表）
获取文件的绝对路径
获取相对路径
获取文件名称
获取文件的大小，单位是字节
获取上次修改时间的毫秒值
列出可用的系统文件根目录
返回的是指定目录下所有文件或者文件夹的名称数组
返回的是指定目录下所有文件或者文件夹对象数组
（4）案例：
获取指定目录下所有.mp4文件的名称
递归_总结
递归（掌握）
（1）方法定义中调用方法本身的现象。
举例：
老和尚给小和尚讲故事，我们学编程。
（2）递归的注意事项：
A:
一定要有出口，否则死递归。
B:
次数不能过多，否则内存溢出。
*****构造方法不能递归调用*****
（3）案例：
（面试可能会有,今天作业题）
A:
递归求8的阶乘
B:
递归求数列第二十项
需求:
用递归求下列数列的第二十项的值：
1，1，2，4，7，13，24...
C:
递归遍历指定目录（你们写Java代码的目录）的文件绝对路径
D:
递归删除带内容的目录（把你们写Java代码的目录复制一份来练习删除）
字符流总结
IO流（掌握）
（1）IO流的分类：
A:
字节流
字节输入流InputStream
字节输出流OutputStream
B:
字符流
字符输入流Reader---FileReader
字符输出流Writer---FileReader
IO流体系图（理解）:
（2）FileWriter写入数据
步骤：
A:
创建字符输出流对象
B:
调用写入数据方法，并刷新缓冲区
C:
释放资源
代码体现：
FileWriterfw=newFileWriter（"a.txt"）;
fw.write（"hello,io"）;
fw.flush（）;
fw.close（）;
问题?
A:
创建字符输出流对象做了几件事情?
a:
创建字符输出流对象
b:
调用对象的写入数据方法，并刷新缓冲区
c:
释放资源
B:
写数据完毕后，为什么要刷新?
C:
为什么要close（）?
1:
让流对象变成垃圾
2：
通知系统去释放和文件相关的资源
D:
flush（）和close（）的区别?
flush（）:
只刷新缓冲区，流对象还可以继续使用。
close（）:
先刷新缓冲区，在关闭流对象。
流对象不可以继续被使用。
E:
怎么实现数据换行?
给出换行符
windows:
\r\n
linu:
\n
mac:
\r
F:
怎么实现数据追加写入?
构造时用带两个参数的
publicFileWriter（StringfileName,true）{}
（3）FileReader读取数据
步骤：
A:
创建字符输入流对象
B:
调用读取数据方法，并显示
C:
释放资源
代码体现：
FileReaderfr=newFileReader（"a.txt"）;
//方式1
//一次读取一个字符
intch=0;
while（（ch=fr.read（））!
=-1）
{
System.out.print（（char）ch）;
}
//方式2
//一次读取一个字符数组
char[]chs=newchar[1024];
intlen=0;
while（（len=fr.read（chs））!
=-1）
{
System.out.print（newString（chs,0,len））;
}
fr.close（）;
（4）案例：
复制文本文件,从D盘中复制一个haha.txt文件（里面字节写上”我爱学Java,我爱学编程”）到E盘下,起名为copy.txt
IO常用流_总结
1：
IO流
（1）分类
字节流：
输入流：
InputStream（抽象类）
intread（）
intread（byte[]bys）
FileInputStream（常用基本流）
BufferedInputStream
输出流：
OutputStream（抽象类）
write（intby）
write（byte[]bys,intindex,intlen）
FileOutputStream（常用基本流）
BufferedOutputStream
字符流：
输入流：
Reader（抽象类）
intread（）
intread（char[]chs）
FileReader（常用基本流）
BufferedReader
StringreadLine（）
输出流：
Writer（抽象类）
write（intch）
write（char[]chs,intindex,intlen）
FileWriter（常用基本流）
BufferedWriter
write（Stringline）
voidnewLine（）
（2）到底使用谁?
用记事本打开能读懂的，就用字符流。
否则，用字节流。
如果你根本就不知道，用字节流。
（3）复制文本文件（了解）：
9种方式：
字节流：
4种
基本流一次读写一个字节
基本流一次读写一个字节数组
高效流一次读写一个字节
高效流一次读写一个字节数组
字符流：
5种
基本流一次读写一个字符
基本流一次读写一个字符数组
高效流一次读写一个字符
高效流一次读写一个字符数组
高效流一次读写一个字符串
一般来说，明明知道是文本文件，那么，肯定不用字节流。
那么，如果是使用字符流，有5种方式，选择哪一种呢?
一般都选择高效流读写一个字符串的方式。
代码体现：
数据源：
c:
\\a.txt
目的地：
d:
\\b.txt
BufferedReaderbr=newBufferedReader（newFileReader（"c:
\\a.txt"））;
BufferedWriterbw=newBufferedWriter（newFileWriter（"d:
\\b.txt"））;
Stringline=null;
while（（line=br.readLine（））!
=null）
{
bw.write（line）;
bw.newLine（）;
bw.flush（）;
}
bw.close（）;
br.close（）;
（4）复制二进制流数据：
（图片，视频，音频等）
字节流：
4种
基本流一次读写一个字节
基本流一次读写一个字节数组
高效流一次读写一个字节
高效流一次读写一个字节数组
一般来说，我们选择使用高效流一次读写一个字节数组
代码体现：
数据源：
c:
\\a.jpg
目的地：
d:
\\b.jpg
BufferedInputStreambis=newBufferedInputStream（newFileInputStream（"c:
\\a.jpg"））;
BufferedOutputStreambos=newBufferedOutputStream（newFileOutputStream（"d:
\\b.jpg"））;
byte[]bys=newbyte[1024];
intlen=0;
while（（len=bis.read（bys））!
=-1）
{
bos.write（bys,0,len）;
}
bos.close（）;
bis.close（）;
1：
IO流
（1）分类
字节流：
输入流：
InputStream
intread（）
intread（byte[]bys）
FileInputStream
BufferedInputStream
输出流：
OutputStream
write（intby）
write（byte[]bys,intindex,intlen）
FileOutputStream
BufferedOutputStream
字符流：
输入流：
Reader
intread（）
intread（char[]chs）
FileReader
BufferedReader
StringreadLine（）
输出流：
Writer
write（intch）
write（char[]chs,intindex,intlen）
FileWriter
BufferedWriter
write（Stringline）
voidnewLine（）
（2）到底使用谁?
如果能用记事本打开，不出现乱码，就优先使用字符流；否则用字节流。
确定上面的情况以后，一般都是用高效流（BufferedXxxx）
（3）复制文本文件：
9种方式：
字节流：
4种
基本流每次操作一个字节
基本流每次操作一个字节数组
高效流每次操作一个字节
高效流每次操作一个字节数组（★）
字符流：
5种
基本流每次操作一个字符
基本流每次操作一个字符数组
高效流每次操作一个字符
高效流每次操作一个字符数组（★）
高效流每次操作一行文本（★）
思路：
1.创建缓冲字符输入流对象（建立于文件系统中文件的对应关系）
2.创建缓冲字符输出流对象（建立于文件系统中文件的对应关系）
3.使用输入流对象的read方法，读出源文件中内容（显示/其他操作）
4.使用输出流对象的write方法，写入数据到目的地文件（需要刷新）
5.关闭流，释放资源
怎么选择使用？
代码体现：
数据源：
a.txt
目的地：
b.txt
思路：
1.创建缓冲字符输入流对象（建立于文件系统中文件的对应关系）
2.创建缓冲字符输出流对象（建立于文件系统中文件的对应关系）
3.使用输入流对象的read方法，读出源文件中内容（显示/其他操作）
4.使用输出流对象的write方法，写入数据到目的地文件（需要刷新）
5.关闭流，释放资源
代码体现：
//创建对象
BufferedReaderbr=null;
BufferedWriterbw=null;
try{
//实例化对象
br=newBufferedReader（newFileReader（"a.txt"））;
bw=newBufferedWriter（newFileWriter（"b.txt"））;
//读取内容
Stringlen=null;
while（（len=br.readLine（））!
=null）{
//写入数据
bw.write（len）;
bw.newLine（）;
bw.flush（）;
}
}catch（Exceptione）{
e.printStackTrace（）;
}finally{
if（br!
=null）{
try{
br.close（）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
if（bw!
=null）{
try{
bw.close（）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
（4）复制二进制流数据：
（图片，视频，音频等）
字节流：
4种
基本流每次操作一个字节
基本流每次操作一个字节数组
高效流每次操作一个字节
高效流每次操作一个字节数组（★）
怎么选择使用？
选用高效流每次操作一个字节数组
代码体现：
数据源：
c:
\\a.jpg
目的地：
d:
\\b.jpg
思路：
1.创建缓冲字节输入流对象（建立于文件系统中文件的对应关系）
2.创建缓冲字节输出流对象（建立于文件系统中文件的对应关系）
3.使用输入流对象的read方法，读出源文件中内容（显示/其他操作）
4.使用输出流对象的write方法，写入数据到目的地文件（需要刷新）
5.关闭流，释放资源
//创建对象
BufferedInputStreambis=null;
BufferedOutputStreambos=null;
try{
//实例化对象
bis=newBufferedInputStream（newFileInputStream（"c:
\\a.jpg"））;
bos=newBufferedOutputStream（newFileOutputStream（"d:
\\b.jpg"））;
//读取
byte[]bys=newbyte[1024];
intlen=0;
while（（len=bis.read（bys））!
=-1）{
//写入数据
bos.write（bys,0,len）;
}
}catch（IOExceptione）{
e.printStackTrace（）;
}fianlly{
if（bis!
=null）{
try{
bis.close（）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
if（bos!
=null）{
try{
bos.close（）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
2：
转换流（理解）
（1）如果有字节流对象，为了使用字符流的功能，就必须使用转换流进行操作。
（2）案例：
键盘录入数据
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
BufferddWriterbw=newBufferedWriter（newFileWriter（"a.txt"））;
Stringline=null
while（（line=br.readLine（））!
=null）
{
if（"over".equals（line））
{
break;
}
bw.write（line）;
bw.newLine（）;
bw.flush（）;
}
bw.close（）;
br.close（）;
把文本文件的数据通过流对象在控制台显示
BufferedReaderbr=newBufferedReader（newFileReader（"a.txt"））;
BufferddWriterbw=newBufferedWriter（newOutputStreamWriter（System.out））;
Stringline=null
while（（line=br.readLine（））!
=null）
{
bw.write（line）;
升级会员 