Java_算法、正则表达式、异常

Java
2.1k 词

算法

排序算法

冒泡排序

  1. 每次从数组中找出最大值放在数组的后面去。

  2. 冒牌排序的步骤分析：

    • 确定总共需要做几轮：数组的长度 - 1
    • 每轮比较几次：数组长度 - 轮次 - 1
    • 当前位置数据大于后一位置则交换数据，否则不进行操作

  3. 代码实现：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    int[] arr = {3,5,2,1,7,4,10,6,8,9};
    int temp;

    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
         	if(arr[j] > arr[j+1]){
    			temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
             }
         }
    }

选择排序

  1. 每轮选择当前位置，开始找出后面的较小值，与该位置交换

  2. 选择排序的步骤分析：

    • 确定总共需要选择几轮：数组长度 -1
    • 控制每轮从当前位置为基准，与后面元素选择几次

  3. 代码实现：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    int[] arr = {3,5,2,1,7,4,10,6,8,9};
    int temp, p;

    for (int i = 0; i < arr.length - 1; i++) {
         p = i;
         for (int j = i + 1; j < arr.length ; j++) {
              if (arr[p] > arr[j]){
                  p = j;
              }
         }

         if (i != p){
                temp = arr[i];
                arr[i] = arr[p];
                arr[p] = temp;
         }
    }

查找算法

二分查找法（折半查找）

  1. 前提：数组中的数据必须是有序的

  2. 核心思想：每次排除一半的数据，查询数据的性能明显提高极多

  3. 代码实现：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public static int binarySearch(int[] arr, int data){
       int left = 0 ,right = arr.length;

       while (left <= right){
           int mid = (right + left)/2;

           if (data < arr[mid]){
                right = mid -1;
           }else if (data > arr[mid]){
                left = mid + 1;
           }else {
                return mid;
           }
       }

       return -1;
    }

正则表达式

概述

  1. 正则表达式：就是由一些指定的字符组成，代表的是一个规则
  2. 作用：
    • 用来校验数据格式是否合法
    • 在一段文本中查找满足要求的内容

书写规则

  1. String类提供了public boolean matches(String regex)方法与正则表达式进行匹配。

  2. 正则表达式书写规则：

    符号 含义 举例
    [] 里面的内容出现一次 [abc]
    ^ 取反 [^abc]
    && 交集，不能写单个的& [a-z&&m-p]
    . 任意字符 \n回车符号不匹配
    \ 转义字符 \\d
    \\d 0-9 \\d+
    \\D 非0-9 \\D+
    \\s 空白字符
    \\S 非空白字符 ^\S
    \\w 单词字符 [a-zA-Z_0-9]
    \\W 非单词字符 [^\w]
    () 分组 a(bc)+
    ` ` 写在括号外表示并集
    ? 0次或1次 \\d?
    * 0次或多次 \\d*
    + 1次或多次 \\d+
    {} 具体次数 a{7}
    (?i) 忽略后面字符的大小写 (?i)abc
    a((?i)b)c 只忽略b的大小写

异常

认识异常

  1. Error：代表系统级别错误（属于严重问题）

  2. Exception：叫异常，它代表的才是我们程序可能出现的问题，所以，Exception以及它的子类来封装程序出现的问题。

    • 运行时异常：RuntimeException及其子类，编译阶段不会出现错误提醒，运行时出现的异常（如：数组索引越界异常）
    • 编译时异常：编译阶段就会出现错误提醒的（如：日期解析异常）

  3. 异常处理方法：

    • 抛出异常（throws）：在方法上使用throws关键字，可以将方法内部出现的异常抛出去给调用者处理。

      1
      2
      3
      方法 throws 异常1, 异常2,……{
          
      }

    • 捕获异常（try……catch）：直接捕获程序出现的异常。

      1
      2
      3
      4
      5
      6
      7
      try{
          // 监视可能出现异常的代码
      }catch(异常类型1 变量){
          // 处理异常
      }catch(异常类型2 变量){
          // 处理异常
      }……

自定义异常

  1. 自定义异常：Java无法将世界上全部问题都提供异常类来代表，如果企业遇到自己的某种问题，想通过异常来表示，以便用异常来管理该问题，那就需要自己来定义异常类了。
  2. 自定义异常的种类：自定义运行时异常、自定义编译时异常
  3. 自定义运行时异常：
    • 定义一个异常类继承RuntimeException
    • 重写构造方法
    • 通过throw new 异常类(xxx)来创建异常对象并抛出。编译阶段不报错，提醒不强烈，运行时才可能出现
  4. 自定义编译时异常：
    • 定义一个异常类继承Exception
    • 重写构造方法
    • 通过throw new 异常类(xxx)来创建异常对象并抛出。编译阶段就报错，提醒更强烈