JAVASE进阶day05（API，异常）

数组高级操作#

1.冒泡排序#

 /**
     * 冒泡排序
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        int a = 0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int i1 = 0; i1 < arr.length-1-i; i1++) {
                if (arr[i1] > arr[i1+1]){
                    a = arr[i1];
                    arr[i1] = arr[i1+1];
                    arr[i1+1] = a;
                }
            }
        }
    }

2.二分数查找 #

 

 Arrays（重要）#

package com.lu.day05.test;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,23,4,54,665,34,123};
        //ArrayUtil.normalSort(arr);
        Arrays.sort(arr);//数组排序
        System.out.println(Arrays.binarySearch(arr, 4));//二分数查找
        System.out.println(Arrays.toString(arr));//打印数组

    }
}

小端的大端排序

a >> 2 //这是一种编程中的位运算表达式，表示将变量 a 的二进制值右移 2 位。>>>表示正数

递归（不重要在java中尽量不要用）#

1.含义#

方法中调用方法本身

2.思路#

把复杂问题转化拆解为同类问题中的一个子问题，递归中要有出口要不然会爆栈内存溢出错误

异常（重要）#

1.为什么引入异常#

使代码更加健壮,提高用户体验2

2.概述#

识别错误并响应错误的机制

3.异常体系#

1.Throwable

1.Error 

VirtualMachineError JVM虚拟机运行错误

stackOverFlowError 栈内存溢出错误

outOfMemoryError（OOM）内存溢出错误

2.Exception

1.RuntimeException运行时异常

        ArithmeticException算数运算异常

        NullPointerException空对象异常（判断是否为null）

        IllegalArgumentException（方法参数不合法）

2.ClassNotFoundException（类找不到异常）编译之后字节码文件找不到

3.IOException

        FileNotFoundException(找不到指定文件)

2.异常分类

4. 异常处理流程#

1.虚拟机自动流程

Step1.虚拟机首先判断有没有手动处理异常

Step2.发生异常创建异常对象

Step3.打印异常信息到控制台

Step4.中断程序运行

2.手动处理流程

throws声明异常

package com.lu.day05.test;

import java.io.FileNotFoundException;
import java.nio.file.FileAlreadyExistsException;

public class ThrowsDome {
    public static void main(String[] args) throws FileNotFoundException {
        show("fsjkl12");
        show2("jflkd");
    }

    /**
     * 声明了一个运行时异常
     * @param s
     * @throws NumberFormatException
     */
    public static void show(String s) throws NumberFormatException{
        Integer fj231 = Integer.valueOf(s);
        System.out.println(fj231);
    }

    /**
     * 声明一个编译时异常
     * @param file
     * @throws FileNotFoundException
     */
    public static void show2(String file) throws FileNotFoundException {
        System.out.println("读取"+file);
    }
}

throw和throws对比

 throw手动抛出异常

package com.lu.day05.test;

import java.io.FileNotFoundException;
import java.util.Objects;


/**
 * 手动处理异常 -- throw抛出异常
 * 优点：1.具备return的作用可以终止程序运行
 *      2.可以自定义异常信息
 * 缺点：抛出编译时异常，需要向上一直声明
 */
public class TrowDome {
    public static void main(String[] args) {
//        parseStringToInteger("123");
//        double[] arr = null;
//        avgArr(arr);
//        test();
        file(null);
    }

    /**
     * 当字符串里面有字母时手动抛出一个异常
     * @param s
     */
    public static void parseStringToInteger(String s){
        char[] chars = s.toCharArray();
        for (char aChar : chars) {
            if (!Character.isDigit(aChar)) {
                throw new RuntimeException("字符串中存在非数字字母" + aChar);//抛出一个异常
            }
        }
        Integer integer = Integer.valueOf(s);
        System.out.println(integer);
    }

    /**
     * 当一个方法具有返回值的时候，如果return哪个值都不合适，那就应该抛出异常
     * @param arr
     * @return
     */
    public static double avgArr(double[] arr){
        if (Objects.isNull(arr) || arr.length == 0){
            throw new RuntimeException("数组不能为零");
        }
        double a = 0;
        for (double j : arr) {
            a += j;
        }
        return a/arr.length;
    }
    public static void test(){
        int i = 1;
        try {
            i = i/0;
        }catch (ArithmeticException e){
            System.out.println("被除数不能为零");
        }

    }
    public static void file(String filePath){
        try {
            if (Objects.isNull(filePath)) {
                throw new RuntimeException("文件名不能为空");
            }
            throw new FileNotFoundException("文件没找到");
        } catch (FileNotFoundException | RuntimeException e) {
            throw new RuntimeException(e);
        }
    }
}

 try...catch捕获异常

public static void test(){
        int i = 1;
        try {
            i = i/0;
        }catch (ArithmeticException e){
            System.out.println("被除数不能为零");
        }
}

5.throwable的成员方法#

package com.lu.day05.test;

public class ThrowAbleDemo {
    public static void main(String[] args) {
        method();
    }
    public static void method(){
        try {
            throw new RuntimeException("运行时异常");
        } catch (RuntimeException e) {
            System.out.println(e.toString());
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
}

 6.自定义异常#

package com.lu.day05.test;

public class Test1 {
    public static void main(String[] args) {
        withdraw(200000);
    }
    public static void withdraw(double money){
        if (money > 10000){
            throw new InsufficientBalanceException("余额不足");
        }
        System.out.println("正常取钱");
    }
}

package com.lu.day05.test;

public class InsufficientBalanceException extends RuntimeException{
    public InsufficientBalanceException() {
    }

    public InsufficientBalanceException(String message) {
        super(message);
    }
}

 

面试题#

1.请说出冒泡排序,选择排序以及二分查找的思路 #

冒泡排序：基本思想：重复地走访要排序的数列，一次比较两个元素，如果顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

选择排序：基本思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

二分数查找：基本思想：也称为折半查找，它是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

2.throw和throws的区别是什么?#

throw：用于在方法体内主动抛出一个异常对象。它会立即终止当前方法的执行，并将异常对象抛给上层调用者。

throws：用于在方法声明处声明该方法可能会抛出的异常类型。它表示该方法不处理这些异常，而是将异常抛给上层调用者来处理。

总的来说，throw是用于主动抛出异常，而throws是用于声明方法可能抛出的异常类型。通过合理使用throw和throws，可以更好地处理程序中的异常情况，提高代码的健壮性。

一个时声明一个是抛出，一个用在方法签名上一个用在方法体内

3.catch捕获多个异常是应该注意什么?#

异常类型的顺序：在捕获多个异常时，应该将子类异常放在父类异常之前捕获。

异常处理的逻辑：对于不同的异常，可能需要采取不同的处理逻辑。在 catch 块中，应该根据异常的类型来执行相应的处理代码，以确保能够正确地处理异常情况。

资源清理：如果在 try 块中使用了一些资源（如文件、数据库连接等），需要在 finally 块中进行资源的清理和释放，以确保资源不会被泄漏。

避免过于宽泛的捕获：尽量避免捕获过于宽泛的异常类型，如 Exception。这样可能会隐藏一些潜在的问题，并且不利于调试和错误排查。应该尽可能地捕获具体的异常类型，以便能够更准确地处理异常情况。

记录异常信息：在处理异常时，应该记录异常的相关信息，如异常消息、堆栈跟踪等，以便于后续的故障排查和分析。

4.手动处理异常的三种方式?#

throws声明异常，throw抛出异常，try...catch捕获异常

5.请问输出什么#

class Annoyance extends Exception {
}
class Sneeze extends Annoyance {
}
public class Human {
    public static void main(String[] args) throws Exception {
        try {
            try {
                throw new Sneeze();
            } catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        } catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
        } 
    }
}
请问输出什么? 改写这个题目,使他符合捕获多个异常的规则