Java学习:基础(正则、Arrays、基本算法、lambda表达式)

• 正则表达式

1）用规定的字符制定一些规则，校验数据的格式合法性

2）字符类，[]默认匹配一个字符

3）预定义字符类，默认匹配一个字符

① . 任意字符 ② \d 数字 ③ \D 非数字 ④ \s 空白字符 ⑤ \S 非空白字符 ⑥ \w 英文、 数字、下划线 ⑦ \W 非单词字符

4）贪婪量次

① ? 匹配0次或1次 ② * 匹配0次或多次 ③ + 匹配1次或多次

• Arrays类

1）数组操作工具类

import java.util.Arrays;

public class ArraysDemo1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 23, 453, 34};
        // 打印数组内容
        System.out.println(Arrays.toString(arr));// 返回 [1, 2, 23, 453, 34]

        // 排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));// 返回 [1, 2, 23, 34, 453]

        // 二分搜索（已排序数组）
        System.out.println(Arrays.binarySearch(arr, 2));// 有返回索引，无返回负数

    }
}

2）自定义排序，自定义比较器只能用引用类型的元素

import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo2 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 23, 453, 34};

        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2; // 左大于右返回正整数，左小于右返回负正整数，相等返回0
            }
        });
        System.out.println(Arrays.toString(arr));// 返回 [1, 2, 23, 34, 453]
    }
}

• 基本算法

1）选择排序，每轮选择当前位置与后面比较，交换位置

import java.util.Arrays;

public class ArraysDemo3 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 23, 453, 34};
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = i+1; j < len; j++) {
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

2）二分查找，已排序，数据元素折半比较

public class ArraysDemo4 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 7, 8, 9};
        int idx = ArraysDemo4.binarySearch(arr, 10);
        System.out.println(idx);
    }
    
    public static int binarySearch(int[] arr, int serachData) {
        // 有返回索引，无返回 -1
        int lidx = 0; // 左位置
        int ridx = arr.length - 1;// 右位置
        while (lidx <= ridx) {
            int midx = (lidx + ridx) / 2; // 中间位置
            if(serachData > arr[midx]) {
                lidx = midx + 1;
            } else if(serachData < arr[midx]) {
                ridx = midx - 1;
            } else {
                return midx;
            }
        }
        return -1;

    }
    
}

• lambda表达式

1）简化匿名内部类

2）函数式接口，必须是接口，且接口中只有一个抽象方法

public class ArraysDemo5 {
    public static void main(String[] args) {
        // 原匿名内部类
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("原匿名内部类跑");
            }
        };
        a.run();

        // 简化
        Animal a1 = ()-> {
            System.out.println("原匿名内部类简化跑");
        };
        go(a1);
    }

    public static void go(Animal a) {
        a.run();
    }
}

@FunctionalInterface
interface Animal {
     void run();
}