java学习（12）

朴灿烈づ我的快乐病毒、 2022-06-16 08:43 138阅读 0赞

**java学习（12）**

> 这篇来写关于java中的异常以及IO流

1.异常

1.1异常：就是程序出现的不正常的情况

> 异常有包括异常和错误：

> > （1）错误：这是非常严重的问题，一般在这里指的是硬件问题

> > （2）异常：

> > 1）编译时期异常：程序运行之前发生的异常
> > 
> > 对于这种异常，我们开始就必须要处理的，如果不处理，后面就走不了

> > 2）运行时期异常：成运行起来之后发生的异常
> > 
> > 开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序
> > 
> >   
> >

1.2体系结构：

>  Throwable：  
>  （1）Error：  
>  （2）Exception：  
>   1）非RuntimeException：编译时期异常  
> 2）RuntimeException：运行时期异常
> 
>   
>

1.3异常的默认处理：

>  针对异常，JVM默认的处理方案：

> >  一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。并且，会自动从当前出问题的地方停止掉。

> 分析：这种处理方案虽然可以及时告诉我们那里有错以及错误的原因，但是对于一个比较大的项目而言，他会有很多的模块或者子程序，单个问题的出现不应该对其他相对独立的模块正常运行造成影响甚至是让其他的模块无法正常运行，一个模块出现异常，其他的模块应该要能正常运行。
> 
>   
>

1.4解决方案：

> 为了解决上面的问题，java中给出了两种方案：

两种方案：

> > A:try...catch...finally

> > B:throws

A：try...catch...finally:

try{
    	可能出现异常的代码
    }catch(异常类名 变量名) {
    	针对异常的代码处理
    }finally {
     释放资源的地方
    }
    简化：
    try{
    		可能出现异常的代码
    }catch(异常类名 变量名) {
    		针对异常的代码处理
    }

示例：对于除数不能为零的异常进行的处理

public static void main(String[] args) {
    		System.out.println("==========");
    		int a= 2;
    		int b = 0;
    		try{
    			System.out.println(a/b);//可能出现异常的代码										
    		}catch(ArithmeticException e){
    			System.out.println("除数为0的异常");
    		}
    		System.out.println("==========");
    	}

结果：

![Center][]

B：这是一种异常抛出的解决方法，后面会进行叙述。

1.5多个异常的处理

> A:针对每一个出现问题的地方写一个try...catch语句

> 分析：就是说，对于每一个问题，都用一个try...catch语句进行异常处理。这里对于除数为0问题以及数组越界问题进行示例：

try{
    		System.out.println(2/0);
    }catch(ArithmeticException e){
    		System.out.println("除数不能为0");
     }
    	 int[] arr = {1,3,5,7};
    	try{
    		System.out.println(arr[6]);
    	}catch(IndexOutOfBoundsException e){
    		System.out.println("数组越界！！！");
    }

> B:针对多个异常，采用一个try，多个catch的情况。

> > try...catch...catch...

> 遇到try里面的问题，就自动和catch里面进行匹配。一旦匹配就执行catch里面的内容，执行完毕后，接着执行后面的代码。利用这种方法对于上面两个问题进行处理：

>     int[] arr = {1,3,5,7};
>     		try{
>     			//System.out.println(arr[6]);
>     			System.out.println(2/0);
>     			
>     		}catch(IndexOutOfBoundsException e){
>     			System.out.println("数组越界!!!");
>     		}catch(ArithmeticException e){
>     			System.out.println("除数不能为0");
>     		}catch(Exception e){		//当前面的异常类都没有匹配到之后，会自动匹配这个异常
>     			System.out.println("出现了其他异常");
>     		}

> 注意：如果异常间有子父关系，父必须在最后
> 
>   
>

1.6编译时期异常和运行时期异常的区别:

> 编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译

> FileNotFoundException（文件未找到异常）

> 运行时期异常：无需显示处理，也可以和编译时异常一样处理

> ArithmeticException
> 
>   
>

1.7Throwable中的方法：

> printStackTrace():打印异常信息，程序从出问题的地方开始就会打印创建一个该异常对应的对象，该对象直接调用打印方法

示例：

try{
    		System.out.println(2/0);	
    	}catch(ArithmeticException e){
    		e.printStackTrace();//打印异常信息		
    	}

1.8区别：

> > 1）try...catch 是直接进行了处理

> > 2）throws则是把异常处理的事情交给了调用者,throws用在方法上，声明方法有异常，交给调用者处理

> > 如果是编译时期异常，调用就必须处理。

> > 如果是运行时期异常，调用者可以处理，也可以不处理。
> > 
> >   
> >

1.9throws:

> > 用在方法声明后面，跟的是异常类名

> > 可以跟多个异常类名，用,号隔开

> > 表示抛出异常，由该方法的调用者来处理

> throws表示出现异常的一种可能，并不一定会发生这些异常
> 
>   
>

1.10异常处理：

> > try...catch...finally

> > finally:一般用于释放资源。在数据库操作或者IO流比较常见。

> > 特点：

> > > 被finally控制的语句体一定会执行

> > > 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

1.11注意：

> A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。

> B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

> C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

\*\*上述仅仅针对编译时期异常，与运行时期异常无关\*\*

1.12 throw和throws的区别

> throws:

> > 1）用在方法声明后面，跟的是异常类名

> > 2）可以跟多个异常类名，用逗号隔开

> > 3）表示抛出异常，由该方法的调用者来处理

> > 4）throws表示出现异常的一种可能性，并不一定会发生这些异常

> throw:

> > 1）用在方法体内，跟的是异常对象名

> > 2）只能抛出一个异常对象名

> > 3）表示抛出异常，由方法体内的语句处理

> > 4）throw则是抛出了异常，执行throw则一定抛出了某种异常
> > 
> >   
> >

2.File

2.1File:

> > 文件和目录(文件夹)路径名的抽象表示形式。

2.2File的构造方法：  
  File(String pathname):把一个路径名称封装成File对象  
  File(String parent, String child):把一个父路径和一个子路径封装成一个File对象  
  File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象

//File(String pathname):把一个路径名称封装成File对象
    		File file = new File("H://a.txt");
    		
    		//File(String parent, String child):
    		//把一个父路径和一个子路径封装成一个File对象
    		File file2 = new File("H://test", "a.txt");
    		
    		//File(File parent, String child):
    		//把一个父路径File对象和一个子路径封装成一个File对象
    		File file3 = new File("H://test");
    		File file4 = new File(file3,"a.txt");

2.3创建功能：

> > A:创建文件

> > > public boolean createNewFile():如果文件不存在，就创建。否则，不创建。

> > B:创建目录

> > > public boolean mkdir():如果目录不存在，就创建。否则，不创建。

> > > public boolean mkdirs():如果目录不存在，就创建。否则，不创建。

即使父目录不存在，也可以连父目录一起创建。

public static void main(String[] args) throws IOException {
    		//先封装一个需要创建的file对象
    		File file = new File("H://a.mp4");
    		//public boolean createNewFile():如果文件不存在，就创建。否则，不创建
    		System.out.println(file.createNewFile());
    			
    		//public boolean mkdir():如果目录不存在，就创建。否则，不创建。
    		//只能创建单层文件夹
    		File file1  = new File("H://bb");
    		System.out.println(file1.mkdir());
    		
    		//public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
    		//即时父目录不存在，也可以连父目录一起创建。
    		File file2  = new File("H://bb//aa//cc//a.txt");
    		System.out.println(file2.mkdirs());
    	}

注意事项：  
  A:你要造什么东西，就应该用对应的方法

2.4删除功能：

> > public boolean delete():既可以删除文件，又可以删除目录。

> 路径问题：

> > A:绝对路径就是以盘符开始的路径

> > B:相对路径就是不以盘符开始的路径，一般都是相对应当前的项目而言的。

> 注意事项：

> > A:Java程序的删除不走回收站。

> > B:如果目录内还有内容就不能删除

代码示例：

public static void main(String[] args) throws IOException {
    		//删除目录和文件夹
    		File file1 = new File("H://a.txt");
    		File file2 = new File("H://test");	
    		File file3 = new File("H://c.txt");
    		file3.createNewFile();
    		
    		//删除功能：
      		//public boolean delete():既可以删除文件，又可以删除目录
    		System.out.println(file1.delete());
    		System.out.println(file2.delete());
    		System.out.println(file3.delete());
    	}

结果：

![Center 1][]

分析:可以看到如果目录不为空，删除方法是不能成功执行的，空目录和文件可以直接删除成功。

2.5判断功能

> > public boolean isDirectory():是否是目录

> > public boolean isFile():是否是文件

> > public boolean exists():是否存在

> > public boolean canRead():是否可读

> > public boolean canWrite():是否可写

> > public boolean isHidden():是否隐藏

示例：

public static void main(String[] args) {
    		//创建一个文件对象
    		File file = new File("H://a.mp4");
    		System.out.println("是否是目录"+"   "+file.isDirectory());
    		System.out.println("是否是文件"+" 	"+file.isFile());
    		System.out.println("是否存在"+" 	"+file.exists());
    		System.out.println("是否可读"+" 	"+file.canRead());
    		System.out.println("是否可写"+" 	"+file.canWrite());
    		System.out.println("是否隐藏"+" 	"+file.isHidden());
    	}

结果：  
![Center 2][]

2.6获取功能

> > public String getAbsolutePath():获取绝对路径

> > public String getPath():获取相对路径

> > public String getName():获取名称

public static void main(String[] args) {
    		//将当前根目录下的a.txt文件封装成对象
    		File file = new File("a.mp4");
    		System.out.println(file.getAbsolutePath());//获取绝对路径
    		System.out.println(file.getPath());//获取相对路径
    		System.out.println(file.getName());//获取名称
    	}

3.字节流及字节高效流  
3.1I/O流的分类

> > IO流分类：

> > > 1）流向：

> > > > > 输入流

> > > > > 输出流

2）数据类型：

> > > > > 字节流

> > > > > > 字节输入流InputStream(抽象类)

> > > > > > 字节输出流OutputStream（抽象类）

> > > > > 字符流

> > > > > > 字符输入流Reader

> > > > > > 字符输出流Writer

注意：一般在讨论IO的分类时，默认是按照数据类型分的

3.2 操作步骤：

> 字节输出流的操作步骤：

> > A:创建字节输出流对象

> > B:调用写数据的方法

> > C:释放资源

示例：将hellow写入文件

public static void main(String[] args) throws IOException {
    		//创建一个a.txt的文件，并且关联文件输出流
    		FileOutputStream fos = new FileOutputStream("H://a.txt");
    		
    		//调用String类的getBytes()方法将字符串转换成字节数组
    		fos.write("helloworld".getBytes());
    		
    		//关流
    		fos.close();
    	}

结果：

![Center 3][]

3.3FileOutputStream写数据的方法

> > write(byte\[\] b)

> > write(int b) ：一次写一个字节

> > write(byte\[\] b, int off, int len) ：一次写一个字节数组的一部分

代码示例：

public static void main(String[] args) throws IOException {
    		//创建字节输出流对象
    		File file = new File("H://b.txt");
    		FileOutputStream fos = new FileOutputStream(file);
    		
    		//write(int b) ：一次写一个字节
    		fos.write(98);
    		
    		//write(byte[] b, int off, int len) ：一次写一个字节数组的一部分
    		byte[] bys = {97,98,99,100};
    		fos.write(bys, 1, 2);
    		
    		//关流
    		fos.close();
    	}

结果：

![Center 4][]

3.4字节输入流：（一次一个字节）

> 字节输入流操作步骤：

> > A:创建字节输入流对象

> > > >  FileInputStream  fis = new FileInputStream("a.txt");

> > B:调用方法读取数据

> > > >  一次读取一个字节：read() 
> > > > 
> > > > 注意：调用read()方法，读到文件结尾会返回-1

> > C:释放资源

> > > >  fis.close

示例：

public static void main(String[] args) throws IOException{
    		//创建字节输入流
    		FileInputStream fis = new FileInputStream("a.txt");
    		//调用方法，读取文件
    		//字节输入流的读取方法：int read()：一次读取一个字节 
    		int by;
    		while ((by=fis.read())!=-1) {
    			//让一次读取文件的一个字节的方法，如果返回值是-1的
    			//时候，无法进入while循环
    			System.out.println(by);
    		}
    		//关流
    		fis.close();
    	}

结果：a.txt存的是前面存进去的helloworld：

![Center 5][]

3.5字节输入流:（一次一个字节数组）

> 字节输入流操作步骤：

> > A:创建字节输入流对象

> > >  FileInputStream  fis = new FileInputStream("a.txt");

> >  B:调用方法读取数据（一次读取一个字节数组，提升效率）

> > >  一次读取一个字节数组： public int read(byte\[\] b):返回实际读取长度,数据被读取到数组中。

> > C:释放资源：fis.close

代码示例：

public static void main(String[] args) throws IOException {
    		//创建输入流对象
    		FileInputStream fis = new FileInputStream("a.txt");
    
    		byte[] byf = new byte[1024];
    		int len;
    		while ((len=fis.read(byf))!=-1) {
    			System.out.println(new String(byf,0,len));
    		}
    		
    		//关流
    		fis.close();
    	}

结果：

![Center 6][]

3.6字节缓冲区流（也叫高效流）：

> > BufferedInputStream(read() 一次读取一个字节, public int read(byte\[\] b):返回实际读取长度,数据被读取到数组中。)

> > BufferedOutputStream（write(byte\[\] b)）

流分类：

> > 低级流: 基本的流，可以直接操作文件。

> > 高级流：是操作基本流的流。

示例：BufferedInputStream同样可以使用字节流的两种读写方法，并且速度比同类型字节流的快。

public static void main(String[] args) throws IOException {
    		//一次读取一个字节数组的时候，复制一个mp4文件
    		//疯转数据源和目的地
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("H://a.mp4"));
    		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("H://j.mp4"));
    		
    //		//1.一次读写一个字节
    //		int by;
    //		while ((by=bis.read())!=-1) {
    //			bos.write(by);
    //		}
    		
    		
    		//2.一次读写一个字节数组
    		byte[] byf = new byte[1024];
    		int len;
    		while ((len = bis.read(byf))!=-1) {
    			bos.write(byf, 0, len);	
    		}
    		
    		
    		//3.关流
    		bos.close();
    		bis.close();
    		
    	}

3.7字节流复制文件（测试所用时间）：

> > A:基本字节流一次读写一个字节

> > B:基本字节流一次读写一个字节数组

> > C:高效字节流一次读写一个字节

> > D:高效字节流一次读写一个字节数组
> > 
> > 获取时间的方法：System.currentTimeMillis()

进行测试，完整的代码：

public static void main(String[] args) throws IOException  {
    		//A:基本字节流一次读写一个字节
    		System.out.println("A:基本字节流一次读写一个字节用时：");
    		long startTime1 = System.currentTimeMillis();
    		method1();
    		long endTime1 = System.currentTimeMillis();
    		System.out.println(endTime1-startTime1);
    		//B:基本字节流一次读写一个字节数组
    		System.out.println("B:基本字节流一次读写一个字节数组用时");
    		long startTime2 = System.currentTimeMillis();
    		method2();
    		long endTime2 = System.currentTimeMillis();
    		System.out.println(endTime2-startTime2);
    		//C:高效字节流一次读写一个字节
    		System.out.println("C:高效字节流一次读写一个字节用时");
    		long startTime3 = System.currentTimeMillis();
    		method3();
    		long endTime3 = System.currentTimeMillis();
    		System.out.println(endTime3-startTime3);
    		//D:高效字节流一次读写一个字节数组
    		System.out.println("D:高效字节流一次读写一个字节数组用时");
    		long startTime4 = System.currentTimeMillis();
    		method4();
    		long endTime4 = System.currentTimeMillis();
    		System.out.println(endTime4-startTime4);
    	}
    
    	private static void method4() throws IOException {
    		//1.封装数据源和目的地
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("H://test.mp4"));
    		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("H://m4.mp4"));
    		//2.一次一次读写一个字节
    		int len;
    		byte[] bys= new byte[1024];
    		while((len=bis.read(bys))!=-1){
    			bos.write(bys,0,len);
    		}
    		//关流
    		bis.close();
    		bos.close();
    		
    	}
    
    	private static void method3() throws IOException {
    		//1.封装数据源和目的地
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("H://test.mp4"));
    		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("H://m3.mp4"));
    		//2.一次一次读写一个字节
    		int by;
    		while((by=bis.read())!=-1){
    			bos.write(by);
    		}
    		//关流
    		bis.close();
    		bos.close();
    		
    	}
    
    	private static void method2() throws IOException {
    		//1.封装数据源和目的地
    		FileInputStream fis = new FileInputStream("H://test.mp4");
    		FileOutputStream fos = new FileOutputStream("H://m2.mp4");
    		//2.一次一次读写一个字节
    		int len;
    		byte[] bys = new byte[1024];
    		while((len=fis.read(bys))!=-1){
    			fos.write(bys, 0, len);
    		}
    		//关流
    		fis.close();
    		fos.close();		
    	}
    
    	private static void method1() throws IOException {
    		//1.封装数据源和目的地
    		FileInputStream fis = new FileInputStream("H://test.mp4");
    		FileOutputStream fos = new FileOutputStream("H://m1.mp4");
    		//2.一次一次读写一个字节
    		int by;
    		while((by=fis.read())!=-1){
    			fos.write(by);
    		}
    		//关流
    		fis.close();
    		fos.close();	
    	}

结果：

![Center 7][]

分析：很明显可以看到四种方法的速度差异，高效字节流一次读写一个字节数组速度是最快的，基本字节流一次读写一个字节是最慢的。

4.编码问题

> String中的编码和解码问题。

> 编码：把我们能够看懂的字符转换为看不懂的数据

> 解码：把我们看不懂的数据转换为看得懂的字符

>  public byte\[\] getBytes(String charsetName)  按照给定的编码方式，编码字节数组（gbk,utf-8）

>  String(byte\[\] bytes, String charsetName) 按照给定的编码方式解码字符数组

代码示例：

public static void main(String[] args) throws UnsupportedEncodingException {
    		//定义一个字符串
    		String encod = "这是一个编码问题";
    		//public byte[] getBytes(String charsetName)  按照给定的编码方式，编码字节数组（gbk,utf-8）
    		byte[] byt = encod.getBytes("gbk");
    		//String(byte[] bytes, String charsetName) 按照给定的编码方式解码字符数组
    		System.out.println(new String(byt, "gbk"));
    		System.out.println(new String(byt, "utf-8"));
    	}

结果：

![Center 8][]  
分析：用什么编码，就必须用什么解码，否则容易出现乱码问题，一般使用默认编码格式，即不选择编码格式，即：

byte[] byt2 = encod.getBytes();
    		  System.out.println(new String(byt2, "gbk"));

同样可以得到一样的解码结果。

[Center]: /images/20220616/ccb9758bb4774aa2a618dcd66aef9ff1.png
[Center 1]: /images/20220616/9024a227cbc8489490b75027ab67a163.png
[Center 2]: /images/20220616/2d2650f14502429eaf7dd2497e417b5b.png
[Center 3]: /images/20220616/e6a238fa8e644eb2b34e8e4b3b2ae9f6.png
[Center 4]: /images/20220616/6d69fef3acab4ed186d11a42f4c2c4c0.png
[Center 5]: /images/20220616/1da5f9e3b17741fdbef35d53cf61d887.png
[Center 6]: /images/20220616/e2226be383d34eb8ba6d75bdba71ce4f.png
[Center 7]: /images/20220616/ddc27064eb3b4b149c4624d432a0517c.png
[Center 8]: /images/20220616/c78d6c899e88466e8dcaad3b38e30259.png