1.1.1 Java异常处理机制
异常结构中的父类Throwable类，其下子类Exceptionlei类和Error类。我们在程序中可以捕获的是Exception的子类异常。
Error系统级别的错误：Java运行时环境出现的错误，我们不可控。
Exception是程序级别的错误：我们可控。
1）异常处理语句：try-catch，如果try块捕获到异常，则到catch块中处理，否则跳过忽略catch块（开发中，一定有解决的办法才写，无法解决就向上抛throws）。
try{//关键字，只能有一个try语句
可能发生异常的代码片段
}catch(Exception e){//列举代码中可能出现的异常类型，可有多个catch语句
当出现了列举的异常类型后，在这里处理，并有针对性的处理
}
2）良好的编程习惯，在异常捕获机制的最后书写catch(Exception e)（父类，顶极异常）捕获未知的错误（或不需要针对处理的错误）。
3）catch的捕获是由上至下的，所以不要把父类异常写在子类异常的上面，否则子类异常永远没有机会处理！在catch块中可以使用方法获取异常信息：
①getMessage()方法：用来得到有关异常事件的信息。
②printStackTrace()方法：用来跟踪异常事件发生时执行堆栈的内容。
4）throw关键字：用于主动抛出一个异常
当我们的方法出现错误时（不一定是真实异常），这个错误我们不应该去解决，而是通知调用方法去解决时，会将这个错误告知外界，而告知外界的方式就是throw异常（抛出异常）catch语句中也可抛出异常。虽然不解决，但要捕获，然后抛出去。
使用环境：
我们常在方法中主动抛出异常，但不是什么情况下我们都应该抛出异常。原则上，自身决定不了的应该抛出。那么方法中什么时候该自己处理异常什么时候抛出？
方法通常有参数，调用者在调用我们的方法帮助解决问题时，通常会传入参数，若我们方法的逻辑是因为参数的错误而引发的异常，应该抛出，若是我们自身的原因应该自己处理。
public static void main(String[] args) {
try{/**通常我们调用方法时需要传入参数的话，那么这些方法，JVM都不会自动处理异常，而是将错误抛给我们解决*/
String result=getGirlFirend("女神"); System.out.println("追到女神了么？"+result);
}catch(Exception e){
System.out.println("没追到");//我们应该在这里捕获异常并处理。
}
}
public static String getGirlFirend(String name){
try{ if("春哥".equals(name)){ return "行";
}else if("曾哥".equals(name)){ return "行";
}else if("我女朋友".equals(name)){ return "不行";
}else{/**当出现了错误(不一定是真实异常)可以主动向外界抛出一个异常！*/
throw new RuntimeException("人家不干！");
}
}catch(NullPointerException e){
throw e;//出了错不解决，抛给调用者解决
}
}
5）throws关键字：不希望直接在某个方法中处理异常，而是希望调用者统一处理该异常。声明方法的时候，我们可以同时声明可能抛出的异常种类，通知调用者强制捕获。就是所谓的“丑话说前面”。原则上throws声明的异常，一定要在该方法中抛出。否则没有意义。相反的，若方法中我们主动通过throw抛出一个异常，应该在throws中声明该种类异常，通知外界捕获。
u 注意事项：
v 注意throw和throws关键字的区别：抛出异常和声明抛出异常。
v 不能在main方法上throws，因为调用者JVM直接关闭程序。
public static void main(String[] args) {
try{ Date today=stringToDate("2013-05-20");
} catch (ParseException e){
//catch中必须含有有效的捕获stringToDate方法throws的异常
// 输出这次错误的栈信息可以直观的查看方法调用过程和出错的根源
e.printStackTrace();
}
}
eg：将一个字符串转换为一个Date对象，抛出的异常是字符格式错误java.text.ParseException
public static Date stringToDate(String str) throws ParseException{
SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-DD");
Date date=format.parse(str);
return date;
}
6）捕获异常两种方式：上例SimpleDataFormat的parse方法在声明的时候就是用了throws，强制我们调用parse方法时必须捕获ParseException，我们的做法有两种：一是添加try-catch捕获该异常，二是在我们的方法中声明出也追加这种异常的抛出（继续往外抛）。
7）java中抛出异常过程：java虚拟机在运行程序时，一但在某行代码运行时出现了错误，JVM会创建这个错误的实例，并抛出。这时JVM会检查出错代码所在的方法是否有try捕获，若有，则检查catch块是否有可以处理该异常的能力（看能否把异常实例作为参数传进去，看有没有匹配的异常类型）。若没有，则将该异常抛给该方法的调用者（向上抛）。以此类推，直到抛至main方法外仍没有解决（即抛给了JVM处理）。那么JVM会终止该程序。
8）java中的异常Exception分为：
①非检测异常（RuntimeException子类）：编译时不检查异常。若方法中抛出该类异常或其子类，那么声明方法时可以不在throws中列举该类抛出的异常。常见的运行时异常有： NullPointerException、 IllegalArgumentException、
ClassCastException、NumberFormatException、
ArrayIndexOutOfBoundsException、ArithmeticException
②可检测异常（非RuntimeException子类）：编译时检查，除了运行时异常之外的异常，都是可检查异常，则必须在声明方法时用throws声明出可能抛出的异常种类！
9）finally块：finally块定义在catch块的最后（所有catch最后），且只能出现一次（0－1次）， 无论程序是否出错都会执行的块！ 无条件执行！通常在finally语句中进行资源的消除工作，如关闭打开的文件，删除临时文件等。
public static void main(String[] args) {
System.out.println( test(null)+","+test("0")+","+test("") ); }
/**输出结果？1,0,2 ？ 4,4,4为正确结果 */
public static int test(String str){
try{ return str.charAt(0)-'0';
}catch(NullPointerException e){ return 1;
}catch(RuntimeException e){ return 2;
}catch(Exception e){ return 3;
}finally{
//无条件执行
return 4;
}
}
10）重写方法时的异常处理
如果使用继承时，在父类别的某个地方上宣告了throws某些异常，而在子类别中重新定义该方法时，可以：①不处理异常（重新定义时不设定throws）。②可仅throws父类别中被重新定义的方法上的某些异常（抛出一个或几个）。③可throws被重新定义的方法上的异常之子类别（抛出异常的子类）。
但不可以：①throws出额外的异常。 ②throws被重新定义的方法上的异常之父类别（抛出了异常的父类）。
1.1.2 File文件类
java使用File类（java.io.File）表示操作系统上文件系统中的文件或目录。换句话说，我们可以使用File操作硬盘上的文件或目录进行创建或删除。
File可以描述文件或目录的名字，大小等信息，但不能对文件的内容操作！File类的构造器都是有参的。
1）关于路径的描述：不同的文件系统差异较大，Linux和Windows就不同！最好使用相对路径，不要用绝对路径。
2）“．”代表的路径：当前目录（项目所处的目录），在eclipse_workspace/project_name下，File.separator：常量，目录分隔符，推荐使用！根据系统自动识别用哪种分割符，windows中为/，Linux中为\。
3）创建该对象并不意味着硬盘上对应路径上就有该文件了，只是在内存中创建了该对象去代表路径指定的文件。当然这个路径对应的文件可能根本不存在！
File file=new File("."+File.separator+"data.dat");// 效果为./data.dat
File file=new File("e:/XX/XXX.txt");//不建议使用
4）createNewFile()中有throws声明，要求强制捕获异常！
5）新建文件或目录：
①boolean mkdir()：只能在已有的目录基础上创建目录。
②boolean mkdirs()：会创建所有必要的父目录（不存在的自动创建）并创建该目录。
③boolean createNewFile()：创建一个空的新文件。
6）创建目录中文件的两种方式：
①直接指定data.dat需要创建的位置，并调用createNewFile()，前提是目录都要存在！
②先创建一个File实例指定data.dat即将存放的目录，若该目录不存在，则创建所有不存在的目录，再创建一个File实例，代表data.dat文件，创建是基于上一个代表目录的File实例的。使用File(File dir,String fileName)构造方法创建File实例，然后再调用createNewFile()：在dir所代表的目录中表示fileName指定的文件
File dir=new File("."+File.separator+"demo"+File.separator+"A");
if(!dir.exists()){ dir.mkdirs();//不存在则创建所有必须的父目录和当亲目录 }
File file=new File(dir,"data.dat");
if(!file.exists()){file.createNewFile();System.out.println("文件创建完毕！"); }
7）查看文件或目录属性常用方法
①long length()：返回文件的长度。
②long lastModified()：返回文件最后一次被修改的时间。
③String getName()：返回文件或目录名。 ⑧String getPath()：返回路径字符串。
④boolean exists()：是否存在。 ⑨boolean isFile()：是否是标准文件。
⑤boolean isDirectory()：是否是目录。 ⑩boolean canRead()：是否可以读取。
⑥boolean canWrite()：是否可以写入、修改。
⑦File[] listFiles()：获取当亲目录的子项（文件或目录）
eg1：File类相关操作
File dir=new File("."); if(dir.exists()&&dir.isDirectory()){//是否为一个目录
File[] files=dir.listFiles();//获取当前目录的子项（文件或目录）
for(File file:files){//循环子项
if(file.isFile()){//若这个子项是一个文件
System.out.println("文件："+file.getName());
}else{ System.out.println("目录："+file.getName()); } } }
eg2：递归遍历出所有子项
File dir=new File("."); File[] files=dir.listFiles(); if(files!=null&&files.length>0){//判断子项数组有项
for(File file:files){//遍历该目录下的所有子项
if(file.isDirectory()){//若子项是目录
listDirectory(file);//不到万不得已，不要使用递归，非常消耗资源
}else{System.out.println("文件："+file);//有路径显示，输出File的toString()
//file.getName()无路径显示，只获取文件名
}
}
}
8）删除一个文件：boolean delete()：①直接写文件名作为路径和"./data.dat"代表相同文件，也可直接写目录名，但要注意第2条。②删除目录时：要确保该目录下没有任何子项后才可以将该目录删除，否则删除失败！
File dir=new File("."); File[] files=dir.listFiles();
if(files!=null&&files.length>0){ for(File file:files){ if(file.isDirectory()){
deleteDirectory(file);//递归删除子目录下的所有子项 }else{
if(!file.delete()){ throw new IOException("无法删除文件："+file); }
System.out.println("文件："+file+"已被删除！"); } }
9）FileFilter：文件过滤器。FileFilter是一个接口，不可实例化，可以规定过滤条件，在获取某个目录时可以通过给定的删选条件来获取满足要求的子项。accept()方法是用来定义过滤条件的参数pathname是将被过滤的目录中的每个子项一次传入进行匹配，若我们认为该子项满足条件则返回true。如下重写accept方法。
FileFilter filter=new FileFilter(){
public boolean accept(File pathname){
return pathname.getName().endsWith(".java");//保留文件名以.java结尾的
//return pathname.length()>1700;按大小过滤 } };
File dir=new File(".");//创建一个目录
File[] sub=dir.listFiles(filter);//获取过滤器中满足条件的子项，回调模式
for(File file:sub){ System.out.println(file); }
10）回调模式：我们定义一段逻辑，在调用其他方法时，将该逻辑通过参数传入。这个方法在执行过程中会调用我们传入的逻辑来达成目的。这种现象就是回调模式。最常见的应用环境：按钮监听器，过滤器的应用。
1.1.3 RandomAccessFile类
可以方便的读写文件内容，但只能一个字节一个字节（byte）的读写8位。
1）计算机的硬盘在保存数据时都是byte by byte的，字节埃着字节。
2）RandomAccessFile打开文件模式：rw：打开文件后可进行读写操作；r：打开文件后只读。
3）RandomAccessFile是基于指针进行读写操作的，指针在哪里就从哪里读写。
①void seek(long pos)方法：从文件开头到设置位置的指针偏移量，在该位置发生下一次读写操作。
②getFilePointer()方法：获取指针当前位置，而seek(0)则将指针移动到文件开始的位置。
③int skipBytes(int n)方法：尝试跳过输入的n个字节。
4）RandomAccessFile类的构造器都是有参的。
①RandomAccessFile构造方法1：
RandomAccessFile raf=new RandomAccessFile(file,"rw");
②RandomAccessFile构造方法2：
RandomAccessFile raf=new RandomAccessFile("data.dat","rw");
直接根据文件路径指定，前提是确保其存在！
5）读写操作完了，不再写了就关闭：close();
6）读写操作：
File file=new File("data.dat");//创建一个File对象用于描述该文件
if(!file.exists()){//不存在则创建该文件
file.createNewFile();//创建该文件，应捕获异常，仅为演示所以抛给main了 }
RandomAccessFile raf=new RandomAccessFile(file,"rw");//创建RandomAccessFile，并将File传入，RandomAccessFile对File表示的文件进行读写操作。
/**1位16进制代表4位2进制；2位16进制代表一个字节 8位2进制；
* 4字节代表32位2进制；write(int) 写一个字节，且是从低8位写*/
int i=0x7fffffff;//写int值最高的8位 raf.write(i>>>24);//00 00 00 7f
raf.write(i>>>16);//00 00 7f ff raf.write(i>>>8);// 00 7f ff ff
raf.write(i);// 7f ff ff ff
byte[] data=new byte[]{0,1,2,3,4,5,6,7,8,9};//定义一个10字节的数组并全部写入文件
raf.write(data);//写到这里，当前文件应该有14个字节了
/**写字节数组的重载方法：write(byte[] data.int offset,int length)，从data数组的offset位置开始写，连续写length个字节到文件中 */
raf.write(data, 2, 5);// {2，3，4，5，6}
System.out.println("当前指针的位置："+raf.getFilePointer());
raf.seek(0);//将指针移动到文件开始的位置
int num=0;//准备读取的int值
int b=raf.read();//读取第一个字节 7f 也从低8位开始
num=num | (b<<24);//01111111 00000000 00000000 00000000
b=raf.read();//读取第二个字节 ff
num=num| (b<<16);//01111111 11111111 00000000 00000000
b=raf.read();//读取第三个字节 ff
num=num| (b<<8);//01111111 11111111 11111111 00000000
b=raf.read();//读取第四个字节 ff
num=num| b;//01111111 11111111 11111111 11111111
System.out.println("int最大值："+num); raf.close();//写完了不再写了就关了
7）常用方法：
①write(int data)：写入第一个字节，且是从低8位写。
②write(byte[] data)：将一组字节写入。
③write(byte[] data.int offset,int length)：从data数组的offset位置开始写，连续写length个字节到文件中。
④writeInt(int)：一次写4个字节，写int值。
⑤writeLong(long)：一次写8个字节，写long值。
⑥writeUTF(String)：以UTF-8编码将字符串连续写入文件。
write……
①int read()：读一个字节，若已经读取到文件末尾，则返回-1。
②int read(byte[] buf)：尝试读取buf.length个字节。并将读取的字节存入buf数组。返回值为实际读取的字节数。
③int readInt()：连续读取4字节，返回该int值
④long readLong()：连续读取8字节，返回该long值
⑤String readUTF()：以UTF-8编码将字符串连续读出文件，返回该字符串值
read……
byte[] buf=new byte[1024];//1k容量 int sum=raf.read(buf);//尝试读取1k的数据
System.out.println("总共读取了："+sum+"个字节");
System.out.println(Arrays.toString(buf)); raf.close();//写完了不再写了就关了
8）复制操作：读取一个文件，将这个文件中的每一个字节写到另一个文件中就完成了复制功能。
try { File srcFile=new File("chang.txt");
RandomAccessFile src=new RandomAccessFile(srcFile,"r");//创建一个用于读取文件的RandomAccessFile用于读取被拷贝的文件
File desFile=new File("chang_copy.txt"); desFile.createNewFile();//创建复制文件
RandomAccessFile des=new RandomAccessFile(desFile,"rw");//创建一个用于写入文件的RandomAccessFile用于写入拷贝的文件
//使用字节数组作为缓冲，批量读写进行复制操作比一个字节一个字节读写效率高的多！
byte[] buff=new byte[1024*100];//100k 创建一个字节数组，读取被拷贝文件的所有字节并写道拷贝文件中
int sum=0;//每次读取的字节数
while((sum=src.read(buff))>0){ des.write(buff,0,sum);//注意！读到多少写多少！}
src.close(); des.close(); System.out.println("复制完毕！");
} catch (FileNotFoundException e) { e.printStackTrace();
} catch (IOException e) { e.printStackTrace(); }
//int data=0;//用于保存每一个读取的字节
//读取一个字节，只要不是－1（文件末尾），就进行复制工作
//while((data=src.read())!=-1){ des.write(data);//将读取的字符写入 }
9）基本类型序列化：将基本类型数据转换为字节数组的过程。writeInt(111):将int值111转换为字节并写入磁盘；持久化：将数据写入磁盘的过程。
1.1.4 基本流：FIS和FOS
Java I/O 输入/输出
流：根据方向分为：输入流和输出流。方向的定了是基于我们的程序的。流向我们程序的流叫做：输入流；从程序向外流的叫做：输出流
我们可以把流想象为管道，管道里流动的水，而java中的流，流动的是字节。
1）输入流是用于获取（读取）数据的，输出流是用于向外输出（写出）数据的。
InputStream：该接口定义了输入流的特征
OutputStream：该接口定义了输出流的特征
2）流根据源头分为：
基本流（节点流）：从特定的地方读写的流类，如磁盘或一块内存区域。即有来源。
处理流（高级流、过滤流）：没有数据来源，不能独立存在，它的存在是用于处理基本流的。是使用一个已经存在的输入流或输出流连接创建的。
3）流根据处理的数据单位不同划分为：
字节流：以一个“字节”为单位，以Stream结尾
字符流：以一个“字符”为单位，以Reader/Writer结尾
4）close()方法：流用完一定要关闭！流关闭后，不能再通过其读、写数据
5）用于读写文件的字节流FIS/FOS（基本流）
①FileInputStream：文件字节输入流。 ②FileOutputStream：文件字节输出流。
6）FileInputStream 常用<u>构造方法</u>：
①FileInputStream(File file)：通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定。即向file文件中写入数据。
②FileInputStream(String filePath)：通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的文件路径名指定。也可直接写当前项目下文件名。
常用<u>方法</u>：
①int read(int d):读取int值的低8位。
②int read(byte[] b):将b数组中所有字节读出，返回读取的字节个数。
③int read(byte[] b,int offset,int length):将b数组中offset位置开始读出length个字节。
④available()方法：返回当前字节输入流 可读取的总字节数。
7）FileOutputStream常用<u>构造方法</u>：
①FileOutputStream(File File)：创建一个向指定File对象表示的文件中写入数据的文件输出流。会重写以前的内容，向file文件中写入数据时，<u>若该文件不存在，则会自动创建该文件。</u>
②FileOubputStream(File file,boolean append)：append为true则对当前文件末尾进行写操作（追加，但不重写以前的）。
③FileOubputStream(String filePath)：创建一个向具有指定名称的文件中写入数据的文件输出流。前提路径存在，写当前目录下的文件名或者全路径。
④FileOubputStream(String filePath,boolean append)：append为true则对当前文件末尾进行写操作（追加，但不重写以前的）。
常用<u>方法</u>：
①void write(int d):写入int值的低8位。
②void write(byte[] d):将d数组中所有字节写入。
③void write(byte[] d,int offset,int length):将d数组中offset位置开始写入length个字节。
1.1.5 缓冲字节高级流：BIS和BOS
对传入的流进行处理加工，可以嵌套使用。
1）BufferedInputStream：缓冲字节输入流
A．构造方法：BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
B．常用方法：
①int read()：从输入流中读取一个字节。
②int read(byte[] b,int offset,int length)：从此字节输入流中给定偏移量offset处开始将各字节读取到指定的 byte 数组中。
2）BufferedOutputStream：缓冲字节输出流
A．构造方法：BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size)
B．常用方法：
①void write(int d)：将指定的字节写入此缓冲的输出流。
②void write(byte[] d,int offset,int length)：将指定 byte数组中从偏移量 offset开始的 length个字节写入此缓冲的输出流。
③void flush()：将缓冲区中的数据一次性写出，“清空”缓冲区。
C．内部维护着一个缓冲区，每次都尽可能的读取更多的字节放入到缓冲区，再将缓冲区中的内容部分或全部返回给用户，因此可以提高读写效率。
3）辨别高级流的简单方法：看构造方法，若构造方法要求传入另一个流，那么这个流就是高级流。所以高级流是没有空参数的构造器的，都需要传入一个流。
4）有缓冲效果的流，一般为写入操作的流，在数据都写完后一定要flush,flush的作用是将缓冲区中未写出的数据一次性写出：bos.flush();即不论缓存区有多少数据，先写过去，缓冲区再下班～确保所有字符都写出
5）使用JDK的话，通常情况下，我们只需要关闭最外层的流。第三方流可能需要一层一层关。
tobehero666.png
网友评论