4. 面向对象高级 - 常用的API

4.1 Arrays 工具类

4.1.1 Arrays 类介绍

数组操作工具类，专门用于操作数组元素

public static int binarySearch (int[] a, int key) :

查找元素在数组中的索引 (二分查找法: 保证数组的元素是排好序的)

- 如果查找的元素, 在数组中不存在: 返回 (-(插入点) - 1)

public class ArraysDemo {
  
    public static void main(String[] args) {

        int[] arr1 = {11, 22, 33, 44, 55};
        int[] arr2 = {11, 22, 33, 44, 66};

        // 将数组元素拼接为带有格式的字符串
        System.out.println(Arrays.toString(arr1));
        // 比较两个数组内容是否相同
        System.out.println(Arrays.equals(arr1, arr2));

        // 查找元素在数组中的索引
        System.out.println(Arrays.binarySearch(arr1, 33));
        System.out.println(Arrays.binarySearch(arr1, 66));

        int[] nums = {22, 11, 55, 44, 33};
        System.out.println(Arrays.binarySearch(nums, 11));      // 1

        Arrays.sort(nums);
        System.out.println(Arrays.binarySearch(nums, 11));      // 0

        // 对数组进行默认升序排序
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

    }
}

4.2 冒泡排序

相邻的两个数进行比较, 如果第一个比第二个大, 就交换他们两个。“每轮”中最大的数值在“最后”。

以数组{22， 55 ， 44 ， 33 ， 11}为例

第一轮比较 :

arr[0]-arr[1] arr[1]-arr[2] arr[2]-arr[3] arr[3]-arr[4] 比较4次

以此类推得：

冒泡排序代码实现如下：

public class BubbleSort {
    /*
        冒泡排序: 相邻的两个数进行比较,  如果第一个比第二个大, 就交换他们两个

        第一轮 : arr[0]-arr[1]  arr[1]-arr[2] arr[2]-arr[3]  arr[3]-arr[4]  比较4次
        第二轮 : arr[0]-arr[1]  arr[1]-arr[2] arr[2]-arr[3]  比较3次
        第三轮 : arr[0]-arr[1]  arr[1]-arr[2] 比较2次
        第四轮 : arr[0]-arr[1]  比较1次
     */
    public static void main(String[] args) {
        int[] arr = {22, 55, 44, 33, 11};

        // 外循环: 比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 内循环: 比较的次数
            // -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));
    }
}

4.3 选择排序

从 0 索引开始，拿着每一个索引上的元素跟后面的元素依次比较。“每轮”把最小的数值放在“最前面”。

第一轮比较 :

arr[0]-arr[1] arr[0]-arr[2] arr[0]-arr[3] arr[0]-arr[4]

以此类推得：

选择排序代码实现如下

public class SelectSort {
    /*
        选择排序: 从 0 索引开始，拿着每一个索引上的元素跟后面的元素依次比较

        第一轮 : arr[0]-arr[1]  arr[0]-arr[2] arr[0]-arr[3] arr[0]-arr[4]
        第二轮 : arr[1]-arr[2]  arr[1]-arr[3] arr[1]-arr[4]
        第三轮 : arr[2]-arr[3]  arr[2]-arr[4]
        第四轮 : arr[3]-arr[4]
     */
    public static void main(String[] args) {
        int[] arr = {22, 11, 44, 33, 55};

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

        System.out.println(Arrays.toString(arr));
    }
}

4.4 二分查找

借助“指针”对有序的数组进行查找元素。

折半查找代码实现如下：

public class BinarySearch {
    /*
        二分查找 (折半查找) :

            前提: 数组元素必须是排好序的

            思路:
                    1. 定义两个变量记录最小索引, 和最大索引
                    2. 折半的动作不止一次, 应该使用循环
                            条件 while(min <= max)
                    3. 循环中计算出中间索引
                    4. 加入判断
                        元素如果大于中间元素 : min = mid + 1;
                        元素如果小于中间元素 : max = mid – 1;
                        元素如果等于中间元素 : 将索引返回 (mid)

     */
    public static void main(String[] args) {

        int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99};

        int index = binarySearch(arr, 100);

        System.out.println(index);

    }

    private static int binarySearch(int[] arr, int num) {
        // 1. 定义两个变量记录最小索引, 和最大索引
        int min = 0;
        int max = arr.length - 1;
        int mid;

        // 2. 折半的动作不止一次, 应该使用循环
        while (min <= max) {
            // 3. 计算中间索引
            mid = (min + max) / 2;
            // 4. 比对
            if (num > arr[mid]) {
                min = mid + 1;
            } else if (num < arr[mid]) {
                max = mid - 1;
            } else {
                return mid;
            }
        }

        // 5. 没找到, 返回-1
        return -1;
    }

}

4.5 正则表达式

用于校验数据格式

了解即可、无需记住，（因为将来百度搜索即可）

4.5.1 String 类中与正则有关的常见方法

4.5.2 练习

具体代码实现如下：

public class RegexTest {
  
    public static void main(String[] args) {

        String qqRegex = "[1-9]\\d{4,11}";
        System.out.println("01256".matches(qqRegex));

        String telRegex = "[1][3-9]\\d{9}";
        System.out.println("15611111111".matches(telRegex));

        System.out.println("-----------------");

        String emailRegex = "\\w+[@][\\w&&[^_]]+(\\.[a-z]{2,3})+";
        System.out.println("zhangSan@itcast.cn".matches(emailRegex));
        System.out.println("zhangsan@itcast.qq.com".matches(emailRegex));
        System.out.println("zhangSanitcast.cn".matches(emailRegex));
        System.out.println("zhangSan@itcast".matches(emailRegex));

    }
}

具体代码是实现如下：

public class PatternTest {
    /*
        需求：请把下面文本中的电话，邮箱，座机号码，热线都爬取出来。
     */
    public static void main(String[] args) {
        String data = "来黑马程序员学习Java，" +
                "电话：18666668888，18699997777或者联系" +
                "邮箱：boniu@itcast.cn 邮箱：bozai@itcast.cn 邮箱2：dlei0009@163.com" +
                "座机电话：01036517895，010-98951256 " +
                "热线电话：400-618-9090 ，400-618-4000，4006184000，4006189090";

        String regex = "[1][3-9]\\d{9}|\\w+[@][\\w&&[^_]]+(\\.[a-z]{2,3})+|[0]\\d{2,3}-?\\d{7,8}|400-?\\d{3}-?\\d{4}";

        // 1. 将正则表达式封装为 Pattern 对象
        Pattern pattern = Pattern.compile(regex);

        // 2. 获取匹配器对象
        Matcher matcher = pattern.matcher(data);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }


    }
}