常见算法、Java - 异常

常见算法、Java - 异常

一、算法

1. 冒泡排序

   • 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

   • 前面的跟接在它后面的比较，也就是相邻两个比较，然后根据升序还是降序交换位置。

   • 分几趟完成，第一趟得到排在最后的元素，排在最后的元素不需要参与下一轮的比较，因为它是最大的，可以节约效率 。

   

• 代码实现冒泡排序 - 根据上图右边索引之间比较找出他们的规律，可以先写两个for循环，然后再整合

    public static void main(String[] args) {
          //每轮比较,得到一个最大值
          //相邻两个元素作比较
  
          int[] arr = {7, 6, 5, 4, 3};
  
          for (int i = 0; i < arr.length - 1; i++) {//i:0~3
              //控制内循环结束范围越来越小  i的值越来越大  所以 内循环范围-i
              for (int j = 1; j < arr.length - i; j++) {//i:0~4
                  // 前面位置j-1   后面位置 j
                  //如果前面位置的元素比后面位置的元素大,交换位置。
                  if (arr[j - 1] > arr[j]) {
                      int temp = arr[j - 1];
                      arr[j - 1] = arr[j];
                      arr[j] = temp;
                  }
              }
          }
          //查看结果
          System.out.println(Arrays.toString(arr));
      }
  

2. 选择排序

• 选择排序（Selection sort）是一种简单直观的排序算法。

• 第一轮：第一个跟第二个比，根据大小交换位置，再用新的第一个跟第三个比，以此类推，确定了第一个放的是最小的

• 第二轮：第二个跟后面的每一个比较，与第一轮类似

• 代码实现冒泡排序 - 整理一下思路和找规律的过程，根据上图右边索引之间比较找出他们的规律，可以先写两个for循环，然后再整合

• public static void main(String[] args) {
        int[] arr = {7, 6, 5, 4, 3};
    
        for (int i = 0; i < arr.length - 1; i++) {
            //内循环索引开始的值越来越大，i的值越来越大  所以让j开始的值=1+i
            for (int j = 1 + i; j < arr.length; j++) {
                //前面位置  i   后面位置 j
                //如果前面位置的元素比后面位置的元素大,交换位置。
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        //打印结果
        System.out.println(Arrays.toString(arr));
    }
  

3. 二分查找

• 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，即表中元素有序排列。

• 原理

  ① 找到首位置和末位置，根据这两个位置获取中间位置(首位置要小于等于末位置)；

  ② 利用中间位置获取中间元素，与要查找的元素作比较。

  ③ 若查找元素比中间元素大(首位置=中间位置+1)，若查找元素比中间元素小(末位置=中间位置-1)，重复上面步骤

  ④ 若查找元素等于中间元素，即为找到，结束查找过程。

• 代码实现冒泡排序 - 整理一下思路和找规律的过程，根据上图设计代码

• public static void main(String[] args) {
      //前提:要查找的数据一定是有序的
      int[] arr = {10, 14, 21, 38, 45, 47, 53, 81, 87, 99};
  
      //记录位置的变量 初始值-1
      int index = -1;
      //要查找的数据
      int findNum = 45;
  
      for (int left = 0, right = arr.length - 1; left <= right; ) {
          //中间位置索引
          int middle = (left + right) / 2;
  
          //判断要查找的元素  和  中间位置的元素的大小
          if (findNum > arr[middle]) {
              //①要找的数据比中间位置的数据大(往右找 left=middle+1)
              left = middle + 1;
          } else if (findNum < arr[middle]) {
              //②要找的数据比中间位置的数据小(往左找 right=middle-1)
              right = middle - 1;
          } else {
              //③要找的数据比中间位置的数据相同(找到了,index =middle)
              index = middle;
              //如果找到了,结束循环。
              break;
          }
      }
      //判断是否找到元素,给出结构
      if (index == -1) {
          System.out.println("没找到");
      } else {
          System.out.println("找到的位置是:" + index);
      }
  }
  

二、异常

1. 概述

   

   //编译时异常,没有默认声明,如果不明确处理,就报错；不声明,则必须捕获,如果被捕获,就不会交给虚拟机;写代码的时候出现的异常，会显示红色，直接继承于Exception;编译时异常，被捕获，不再需要通过throws声明
   
   //运行时异常,默认被声明: throws  RuntimeException；可以被捕获,如果被捕获,就不会交给虚拟机；运行代码才会产生，先继承于RuntimeException类，再继承于Exception类;运行时异常,被捕获，优先以捕获形式处理
   
   //自己定义方法throws 了异常，在main( )中调用，main方法也要抛一次，然后JVM作为main方法的调用者，会输出异常信息；
   //接受了一个编译时异常  如果在main方法中抛异常,意味着抛给了虚拟机(虚拟机发现出错,结束虚拟机)
   
   

2. 异常传递图解

   

3. 异常的体系

   

4. 异常的声明

   

5. 异常的捕获

   

   • 系统一旦能走到 try{} 里面，finally也一定执行
   • try{} 里面的代码越少越好，不会出现问题的代码就不要往里写，不必要的操作
   • 如果具备关联性操作的代码,要一并放入try中。
   • try{} 中的代码比如有三行，第一、三行有异常，那么在第一行执行的时候就会停止，然后执行catch中的语句和finally中的语句，第三行是根本就没法经过的，因为try{}中代码只要有一行有问题，后面的代码压根不执行了

6. finally 关键字

   

7. 使用形式

   

   • 异常的捕获还是要分开处理，不同类型的异常，分开catch

   • 多个异常一次捕获，捕获父类Exception就行，体现了多态

   • 多个catch的异常类之间，前面的异常类不能比后面的异常类高，不然压根没机会捕捉后面的。

   • finally里的代码如果写在外面，如果catch中又有异常，是会直接终止的，语句不执行

8. 注意事项

   

9. 自定义异常