常用API学习（四）：Arrays工具类（冒泡排序、二分查找）和正则表达式。

一. API-Arrays工具类

1. Arrays类

概述：数组操作工具类，专门用于操作数组元素的。

Arrays工具类常用方法：

示例代码：

public class ArraysDemo {
    public static void main(String[] args) {
        //定义一个整型数组int[] arr;
        int[] arr = {11, 2, 6, 5, 65, 65, 65, 62};
        //1.Arrays.toString()打印数组，返回数组的字符串
        System.out.println(Arrays.toString(arr));
        //2.Arrays.copyOfRange()截取数组指定的索引位置,索引包前不包后
        int[] newArr = Arrays.copyOfRange(arr, 1, 4);
        System.out.println(Arrays.toString(newArr));
        //3.Arrays.copyOf()，拷贝指定长度的数组
        int[] newArr1 = Arrays.copyOf(arr, 4);
        System.out.println(Arrays.toString(newArr1));
        //4. Arrays.sort(arr),数组排序，默认升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

2. Arrays类的排序方法（重要）

自定义排序的方法：

3. Comparator排序接口的使用（重要）

根据实际的需求自定义排序。

Comparator接口的核心方法是compare方法。

格式：

int compare(T obj1,T obj2);

该方法接受两个参数，表示需要比较的两个对象，返回一个整数值，表示 obj1 和 obj2 的大小关系。该方法的返回值有以下规则：

• 如果 obj1 小于 obj2，则返回负整数；
• 如果 obj1 等于 obj2，则返回 0；
• 如果 obj1 大于 obj2，则返回正整数。

使用 Comparator 接口，可以自定义对象之间的比较规则。常见的应用场景有：

1. 对象排序：可以通过实现 Comparator 接口的 compare 方法，定义对象的比较规则，然后通过调用 Arrays.sort() 或 Collections.sort() 方法来对对象进行排序。
2. TreeSet 和 TreeMap：这两个集合类是基于红黑树实现的，它们默认按照对象的自然顺序进行排序。但是，如果对象没有实现 Comparable 接口，或者希望按照其他比较规则进行排序，可以使用 Comparator 接口来指定排序规则。

使用 Comparator 接口进行对象排序的示例代码：

public class ArraysStudentTest {
    public static void main(String[] args) {
        Student[] students = new Student[5];
        students[0] = new Student("小敏", 18, 100, 100, 100);
        students[1] = new Student("小红", 19, 36, 36, 99);
        students[2] = new Student("小名", 17, 98, 55, 99);
        students[3] = new Student("小军", 22, 67, 45, 89);
        students[4] = new Student("小狗", 20, 55, 100, 99);
        //使用匿名内部类
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }
    }
}

4. 冒泡排序

示例代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {11, 5, 13, 2};
        //冒泡排序
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

弊端：这种冒泡排序是考虑极端坏的情况下，算法进行比较浪费资源。

5. 优化冒泡排序（重要）

优化思想：通过记录内层排序交换是否进行，可以判断出排序是否完成。

示例代码：

//优化冒泡排序
        Random random = new Random();
        int[] brr = new int[20];
        //循环给数组随机生成20个0~100之间数据
        for (int i = 0; i < brr.length; i++) {
            brr[i] = random.nextInt(100);
        }
        //优化排序
        for (int i = 0; i < brr.length - 1; i++) {
            //定义一个变量stare记录内层判断是否执行,每次默认已经排序完成true,当排序没完成是改变state的值为false。
            boolean state = true;
            for (int j = 0; j < brr.length - 1 - i; j++) {
                if (brr[j] > brr[j + 1]) {
                    int temp = brr[j];
                    brr[j] = brr[j + 1];
                    brr[j + 1] = temp;
                    //当内层循环判断执行时证明排序未完成，改变state的值为false.
                    state = false;
                }
            }
            //当state的值一直是true时，证明数组已经排序完成结束循环排序。
            if (state) {
                break;
            }
            System.out.println("第" + i + "轮排序：" + Arrays.toString(brr));
        }

6. 二分查找

二分查找的前提必须是数组有序。

代码示例：

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {25, 36, 69, 78, 99, 102, 369};
        System.out.println(binarySearch(arr, 102));
        System.out.println(binarySearch(arr, 106));
        System.out.println(binarySearch(arr, 69));
    }

    //二分查找法：arr(查询的数组) target:查询的数据
    public static int binarySearch(int[] arr, int target) {
        //声明左右指针（限制查询的范围）
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int middle = (right + left) / 2;
            if (arr[middle] == target) {
                return middle;//如果中间索引元素就是目标元素，则middle就是目标元素的索引。
            } else if (target > arr[middle]) {
                left = middle + 1;//如果target在中间元素的右边，则挪动左指针变为中间指针+1.
            } else {
                right = middle - 1;//如果target在中间元素的左边，则挪动右指针变为中间指针-1.
            }
        }
        return -1;//如果while循环结束就说明目标元素不在数组中，则返回-1.
    }
}

二. 正则表达式（重要）

概述：就是由一些特定的字符组成，代表的是一个规则。

String提供了一个匹配正则表达式的方法：

//判断字符串是否符合正则表达式，匹配返回true，不匹配返回false。
public boolean matches(String regex)

正则表达式的书写规则：

1. 字符类（只能匹配单个字符）

2. 预定义字符（只能匹配单个字符）

注意：在java中“\”有特殊含义，在java中需要编写两个“\”告诉虚拟机没有特殊含义，不需要转义。

3. 数量词

代码示例：

public static void checkMobileNumber(String mobileNumber) {
    /*
    分析:手机号码范例【13833348009】【17710327783】
       (1)手机号总长11位,手机号码的第一位一定是1 => [1]
       (2)根据现行手机号规范要求,第二位的范围在3-9之间 => [3-9]
       (3)剩余的9位必须是数字而且必须是9位 \\d{9}
    */
    String mobileNumberRegex = "[1][3-9]\\d{9}";
    System.out.println("手机号码【" + mobileNumber + "】是否符合要求:" + mobileNumber.matches(mobileNumberRegex));
}

public static void checkPhoneNumber(String phoneNumber) {
    /*
    分析:座机号码范例【010-12345】【0313-3067865】【021-3878263】【010123456】
        (1)区号可以三位也可以为四位必须是数字,第一位必须是0 [0]\\d{2,3}
        (2)区号与座机号中的-可以有也没有 [-]?
        (3)座机号可以最少5位最多8位 \\d{5,8}
     */
    String phoneNumberRegex = "[0]\\d{2,3}[-]?\\d{5,8}";
    System.out.println("手机号码【" + phoneNumber + "】是否符合要求:" + phoneNumber.matches(phoneNumberRegex));
}