Java中常见异常处理、文件File类、流的知识点总结

一、常见的异常处理情况

  在Java中常见的两种异常处理：捕捉异常（try-catch-finally）和抛出异常（throw-throws）

1.捕捉异常（try/catch/finally）:

用捕捉异常时，不能try、catch、finally单独使用，需要配套使用，入try-catch、try-catch-finally等

基本语法结构：

try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1){  
    // 捕获并处置try抛出的异常类型Type1  
}  
catch (Type2 id2){  
     //捕获并处置try抛出的异常类型Type2  
}  finally{
//不管有没处理异常都会执行这行代码
}

其中，catch可以有多个，但是注意catch中Type异常类型是由小到大（从子类到父类），否则下面的子类不会执行；finally用于结束异常处理，退出异常处理区。

2.抛出异常（throw-throws）

用抛出异常时，throw针对对象的做法，而throws是针对一个方法抛出的异常

基本结构：

throws：

import java.lang.Exception;  
public class TestException {  
    static void pop() throws NegativeArraySizeException {  
        // 定义方法并抛出NegativeArraySizeException异常  
        int[] arr = new int[-3]; // 创建数组  
    }  
  
    public static void main(String[] args) { // 主方法  
        try { // try语句处理异常信息  
            pop(); // 调用pop()方法  
        } catch (NegativeArraySizeException e) {  
            System.out.println("pop()方法抛出的异常");// 输出异常信息  
        }  
    }  
  
}  

throw：

public class One {
public void yichang(){
NumberFormatException e = new NumberFormatException();
throw e;
}
public static void main(String[] args){
One test = new One();
try{
test.yichang();
}catch(NumberFormatException e){
System.out.println(e.getMessage());
}
}
}

二、文件File类

File：文件和目录路径名的抽象表达式，File类的实例是不可变得，一旦创建，File对象表示的抽象路径名将永不改变

File实例（实现在控制台上输出一个路径，得到该路径下的所有文件）：

注意：这里用到了递归的方法来实现循环调用查找方法！

package File_test;

import java.io.File;
import java.util.Scanner;

import javax.swing.JTextArea;

public class File_test {
	public static  void main(String[] args) {

		// 创建控制台输入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个搜索路径：");
		String a = sc.nextLine();
		File_test ft = new File_test();
		ft.searchFile(a);
	}

	public void searchFile(String a) {
		File file = new File(a);
		// 判断File是文件还是文件夹
		if (file.isFile()) {
			// 直接打印路径
			System.out.println(file.getAbsolutePath());

		} else {
			// 获取当前文件夹的files对象
			File[] files = file.listFiles();
			// 防止空指针报错
			if (files != null) {
				// 遍历子文件的files对象
				for (int i = 0; i < files.length; i++) {
					File childFile = files[i];
					searchFile(childFile.getAbsolutePath());
					// System.out.println(childFile.getAbsolutePath());
				}
			}

		}
	}
}

三、I/O流

I/O流分为字节流（在读取和写入数据时，以字节为单位进行读取和写入）和字符流（在读取和写入数据时，以字符为单位进行读取和写入）；输入流：将数据从其他存储机制中读入到内存机制当中，输出流：将内存机制中的数据写到其他存储机制中去。

（1）字节流实例：

package com.huaxin.iotest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileStream {
	public static void main(String[] args) {
		FileStream fs = new FileStream();
		fs.writeBytesFile();
	}
	/**
	 * 文件字节输入流测试
	 */
	public void readBytesFile(){
		try {
			//创建一个文件输入流对象
			FileInputStream fis = new FileInputStream("文件测试.txt");
			int result = fis.available();
			System.out.println("流中剩余字节数为："+result);
		
			//字节数组读取
			byte[] bytes = new byte[5];
			int count = fis.read(bytes);
			while(count!=-1){
				//打印输出数组
				for (int i = 0; i < count; i++) {
					System.out.println((char)bytes[i]);
				}
				//读取下一个字节数组内容
				count = fis.read(bytes);
			}
			
			fis.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 文件字节输出流测试
	 */
	public void writeBytesFile(){
		try {
			//创建文件输出流，文件可以不存在，但是路径必须存在,没写入一次，清空文件数组再写入
			FileOutputStream  fos = new FileOutputStream("输出流测试.txt");
//			//对文件内容进行操作
//			for (int i = 0; i < 10; i++) {
//				fos.write(99);
//			}
			//字节数组实现文件写入
			byte[] bytes = {97,98,99,100,101,102,103};
//			fos.write(bytes);
			fos.write(bytes,2,4);
			fos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

（2）字符流实例：

package com.huaxin.iotest;

import java.io.FileReader;
import java.io.FileWriter;

public class FileCharStream {
	public static void main(String[] args) {
		FileCharStream fcs = new FileCharStream();
		fcs.writeCharFile();
	}
	public void readCharFile(){
		//创建文件字符流队形
		try {
			FileReader fr = new FileReader("文件测试.txt");
		
			
//			//读取一个字符
//			int value = fr.read();
//			while(value!=-1){
//				//转化为字符打印
//				System.out.println((char)value);
//				value = fr.read();
//			}
			
			char[] chars = new char[512];
			int r = fr.read(chars);
			while(r!=-1){
				for (int i = 0; i < r; i++) {
					System.out.println((char)chars[i]);
				}
				r = fr.read(chars);
			}
			
			fr.close();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 文件字节输出流测试
	 */
	public void writeCharFile(){
		try {
			//创建文件输出流，文件可以不存在，但是路径必须存在,没写入一次，清空文件数组再写入
			FileWriter  fos = new FileWriter("文件测试.txt",true);
			String str = "山不在高，有仙则灵";
//			fos.write(str);
			//把字符串转化为字符数组
			char[] chars = str.toCharArray();
			fos.write(chars);
			fos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

（3）用字节流实现文件复制功能

package I_O;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileCopy_1 {
	// 设置程序入口
	public static void main(String[] args) {
		FileCopy_1 fc_1 = new FileCopy_1();
		fc_1.copyFile();
	}

	// 用字节流实现文本复制功能
	public void copyFile() {
		try {
			FileOutputStream fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\猜数游戏实验报告_copy.doc");
			FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\猜数游戏实验报告2.doc");
			byte[] bytes = new byte[10];
			int count=fis.read(bytes);
			while(count!=-1){
				fos.write(bytes);
				count=fis.read(bytes);
			}

		} catch (Exception e) {

			e.printStackTrace();
		}
	}
}

实现结果：