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

算法

排序算法

冒泡排序

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

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

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

3. 代码实现：

   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. 代码实现：

   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. 代码实现：

   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关键字，可以将方法内部出现的异常抛出去给调用者处理。

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

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

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

自定义异常

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