Java学习记录（四）

Java学习记录（四）：常用API与一些基本算法

1、正则表达式1：匹配电话号码、座机号码以及电子邮件

public class RegexDemo1 {
    public static void main(String[] args) {
        String[] phoneNumbers = {"13112345678", "13712345667", "13712345667", "139456790271"};
        String[] landLineNumbers = {"020-2324242", "02122442", "027-42424", "0712-3242434"};
        String[] emails = {"3232323@qq.com", "zhangsan@itcast.cnn", "dleieee9@163.com", "dleieee9@pci.com.cn"};

        for (String phoneNumber : phoneNumbers) {
            String regex = "\\d{11}";
            boolean isMatch = phoneNumber.matches(regex);
            System.out.println(phoneNumber + ": " + isMatch);
        }

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

        for (String landLineNumber : landLineNumbers) {
            String regex = "\\d{3}-\\d{7}";
            boolean isMatch = landLineNumber.matches(regex);
            System.out.println(landLineNumber + ": " + isMatch);
        }

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

        for (String email : emails) {
            String regex = "[a-zA-Z0-9]+@[a-zA-Z0-9]+(\\.[a-zA-Z0-9]+){1,2}";
            boolean isMatch = email.matches(regex);
            System.out.println(email + ": " + isMatch);
        }
    }
}

2、正则表达式2：匹配用户名以及身份证号号码，用户名要求为字母、数字或下划线4-16位的任意组合，身份证号码总共18为，最后一位可以是大小的的X或数字。

public class RegexDemo2 {
    public static void main(String[] args) {
        String username = "Aa1234__";
        String regex1 = "\\w{4,16}";
        System.out.println(username + ": " + username.matches(regex1));

        String[] ids = {"41083119930228457x", "510801197609822309", "15040119810705387X", "130133197204039024", "430102197606046442"};
        for (String id : ids) {
            String regex = "\\d{17}[xX0-9]";
            System.out.println(id + ": " + id.matches(regex));
        }

    }
}

3、正则表达式3：从一段文本中爬取想要的字符串，包含()、?=、?!、?:的使用方法。

public class RegexDemo3 {
    public static void main(String[] args) {
        String str = "Java自从95年问世以来，经历了很多版木，目前企业中用的最多的是Java8和Java11，因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在未来不久Java17也会逐渐登上历史舞台。";
        String regex = "(Java[1-9]?\\d?)";

        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(str);

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

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

        String regex2 = "Java(8|11|17)";
        p = Pattern.compile(regex2);
        m = p.matcher(str);
        while (m.find()) {
            String result = m.group();
            System.out.println(result);
            System.out.println(result.substring(0, 4));

        }

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

        // ?=表示输出前面部分
        regex2 = "Java(?=8|11|17)";
        p = Pattern.compile(regex2);
        m = p.matcher(str);
        while (m.find()) {
            String result = m.group();
            System.out.println(result);
//            System.out.println(result.substring(0, 4));

        }

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

        // ?!表示输出前面部分，但只输出一次
        regex2 = "Java(?!8|11|17)";
        p = Pattern.compile(regex2);
        m = p.matcher(str);
        while (m.find()) {
            String result = m.group();
            System.out.println(result);
//            System.out.println(result.substring(0, 4));

        }

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

        // ?:表示输出所有部分
        regex2 = "Java(?:8|11|17)";
        p = Pattern.compile(regex2);
        m = p.matcher(str);
        while (m.find()) {
            String result = m.group();
            System.out.println(result);
//            System.out.println(result.substring(0, 4));

        }
    }
}

4、正则表达式4：()分组用法。

public class RegexDemo4 {
    public static void main(String[] args) {
        String[] strings1 = {"a123a", "b456b", "17891", "&abc&", "a123b"};
        String[] strings2 = {"abc123abc", "b456b", "123789123", "&!@abc&!@", "abc123abd"};
        String[] strings3 = {"aaa123aaa", "bbb456bbb", "111789111", "&&abc&&"};

        // 匹配头尾单个字符，相同为真，否则为假
        String regex1 = "(.).+\\1";
        for (String string : strings1) {
            boolean result = string.matches(regex1);
            System.out.println(result);
        }

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

        // 匹配首尾多个字符，相同为真
        String regex2 = "(.+).+\\1";
        for (String string : strings2) {
            boolean result = string.matches(regex2);
            System.out.println(result);
        }

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

        // 匹配首尾多个相同字符，相同为真
        String regex3 = "((.)\\2+).+\\1";
        for (String string : strings3) {
            boolean result = string.matches(regex3);
            System.out.println(result);
        }
    }
}

5、判断有多少个水仙花数（三位数中的自幂数）、多少个四叶玫瑰数（四位数中的自幂数）、多少个五角星数（五位数中的自幂数），最后2位数中是否有自幂数。使用ArrayList和Math库。

public class Algorithm1 {
    public static void main(String[] args) {
        // 水仙花数
        amountOfNumber(100, 999);
        // 四叶玫瑰数
        amountOfNumber(1000, 9999);
        // 五角星数
        amountOfNumber(10000, 99999);
        // 是否无两位数的自幂数？
        identifyNoTwoDigitArmstrongNumber();
    }

    public static boolean judgeArmstrongNumber(int number) {
        int n = 0;
        ArrayList<Integer> numList = new ArrayList<>();
        int tempNumber = number;
        while (tempNumber != 0) {
            numList.add(tempNumber % 10);
            tempNumber /= 10;
            n++;
        }

        double result = 0;
        for (Integer integer : numList) {
            result += Math.pow(integer, n);
        }

        return number == result;
    }

    public static void amountOfNumber(int start, int end){
        int counter = 0;
        for (int i = start; i < end; i++) {
            if (judgeArmstrongNumber(i)) {
                counter++;
            }
        }

        System.out.println(counter);
    }

    public static void identifyNoTwoDigitArmstrongNumber(){
        int counter = 0;
        for (int i = 10; i < 99; i++) {
            if (judgeArmstrongNumber(i)) {
                counter++;
            }
        }

        System.out.println(counter == 0);
    }
}

6、将十进制数转换成任意进制

public class Decimal2AnyBase {
    public static void main(String[] args) {
        int num = 221;

        System.out.println("2进制: " + decimal2AnyBase(num, 2));
        System.out.println("8进制: " + decimal2AnyBase(num, 8));
        System.out.println("16进制: " + decimal2AnyBase(num, 16));
    }

    public static String decimal2AnyBase(int num, int base) {
        String[] hexes = {"A", "B", "C", "D", "E", "F"};

        if (base == 2 && num < 1){
            return "0";
        }

        if (base == 8 && num < 8){
            return String.valueOf(num);
        }

        if (base == 16 && num < 16){
            if (num < 10) {
                return String.valueOf(num);
            } else {
                return hexes[num - 10];
            }
        }

        StringBuilder stringBuilder = new StringBuilder();

        while (num > 0) {
            int remainder = num % base;

            if (base == 16){
                if (remainder > 9){
                    stringBuilder.append(hexes[remainder - 10]);
                    num /= base;
                    continue;
                }
            }

            stringBuilder.append(remainder);
            num /= base;
        }

        return stringBuilder.reverse().toString();
    }
}

7、任意进制转换成10进制

public class AnyBase2Decimal {
    public static void main(String[] args) {
        String hex = "DD";
        String oct = "335";
        String bin = "11011101";

        System.out.println("hex to dec: " + anyBase2Decimal(hex, 16));
        System.out.println("oct to dec: " + anyBase2Decimal(oct, 8));
        System.out.println("bin to dec: " + anyBase2Decimal(bin, 2));
    }

    public static int anyBase2Decimal(String num, int base) {
        int[] hexes = {10, 11, 12, 13, 14, 15};
        int result = 0;
        int power = num.length() - 1;

        for (int i = 0; i < num.length(); i++) {
            char ch = num.charAt(i);
            if (base == 16) {
                if (ch >= 'A' && ch <= 'E') {
                    result += (int) (hexes[ch - 'A'] * Math.pow(base, power--));
                } else {
                    result += (int) ((ch - '0') * Math.pow(base, power--));
                }
            }
            if (base == 8 || base == 2){
                result += (int) ((ch - '0') * Math.pow(base, power--));
            }
        }

        return result;
    }
}

8、JDK8以前的日期类以及日期格式化类的使用方法

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatTest {
    public static void main(String[] args) throws ParseException {
        String birthdate = "2000-11-11";

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = simpleDateFormat.parse(birthdate);
        long time1 = d1.getTime();

        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日");
        Date d2 = new Date(time1);
        String birthdate1 = simpleDateFormat1.format(d2);

        System.out.println(birthdate1);
    }
}

9、Calender类测试

import java.util.Calendar;
import java.util.Date;

public class CalenderTest {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        c.setTime(new Date(0L));
        System.out.println(c.getTime());

        System.out.println(c.getTimeInMillis());

        c.setTimeInMillis(System.currentTimeMillis());
        System.out.println(c.getTime());

        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH));
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.HOUR_OF_DAY));
        System.out.println(c.get(Calendar.MINUTE));
        System.out.println(c.get(Calendar.SECOND));
        System.out.println(c.get(Calendar.DAY_OF_WEEK));


        c.set(Calendar.YEAR, 2023);
        System.out.println(c.getTime());

        c.add(Calendar.MONTH, 2);
        System.out.println(c.getTime());

        c.add(Calendar.MONTH, -1);
        System.out.println(c.getTime());
    }
}

10、JDK8以后相关类的使用：ZoneID、ZoneDatatime、Instant测试

（1）ZoneID

import java.time.ZoneId;

public class ZoneIdTest {
    public static void main(String[] args) {
        System.out.println(ZoneId.getAvailableZoneIds());
        System.out.println(ZoneId.systemDefault());
        System.out.println(ZoneId.of("Asia/Shanghai").getRules());
    }
}

（2）Instant

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class InstantTest {
    public static void main(String[] args) {
        Instant now = Instant.now();
        System.out.println(now);

        System.out.println(Instant.ofEpochMilli(1000L));
        System.out.println(Instant.ofEpochSecond(10L));
        System.out.println(Instant.ofEpochSecond(10L, 1000000000L));

        ZonedDateTime zonedDateTime = now.atZone(ZoneId.of("Asia/Shanghai"));
        System.out.println(zonedDateTime);

        System.out.println(now.minusSeconds(20));
        System.out.println(now.plusSeconds(20));
    }
}

（3）ZoneDataTime

import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class ZoneDataTimeTest {
    public static void main(String[] args) {
        System.out.println(ZonedDateTime.now());

        ZonedDateTime zdt = ZonedDateTime.now();

        ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(Instant.ofEpochMilli(0L), ZoneId.of("Asia/Shanghai"));
        System.out.println(zonedDateTime);

        System.out.println(zdt.withYear(2022));

        System.out.println(zdt.minusYears(10));

        System.out.println(zdt.plusYears(11));
    }
}

11、DateTimeFormatter使用方法，具体格式和SimpleDateFormat一样。

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeFormatterTest {
    public static void main(String[] args) {
        ZonedDateTime now = ZonedDateTime.now();

        System.out.println(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss").format(now));
    }
}

12、LocalData方法测试，LocalTime和LocalDataTim方法差不多，就没有具体给出例子。

import java.time.LocalDate;

public class LocalDateTest {
    public static void main(String[] args) {
        LocalDate now = LocalDate.now();
        LocalDate d1 = LocalDate.of(2022, 2, 3);

        System.out.println(now.isEqual(LocalDate.now()));
        System.out.println(now.isBefore(d1));
        System.out.println(now.isAfter(d1));
        System.out.println(now.minusDays(5));
        System.out.println(now.plusDays(10));
        System.out.println(now.isLeapYear());
        System.out.println(now.getEra());
        System.out.println(now.getYear());
    }
}

13、秒杀活动：活动时间为2023年11月11日 0:0:0至2023年11月11日 0:10:0共10分钟，存在两个时间点，若在这个区间内秒杀成功，否则秒杀失败。涉及到时间的比较，这里用Date类和SimpleDateFormat类实现。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class FlashSale {
    public static void main(String[] args) throws ParseException {
        String startTime = "2023年11月11日 0:0:0";
        String endTime = "2023年11月11日 0:10:0";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

        Date d1 = sdf.parse(startTime);
        Date d2 = sdf.parse(endTime);

        Date o1Date = sdf.parse("2023年11月11日 0:1:0");
        Date o2Date = sdf.parse("2023年11月11日 0:11:0");

        if (o1Date.getTime() >= d1.getTime() && o1Date.getTime() <= d2.getTime()) {
            System.out.println("秒杀成功！");
        } else {
            System.out.println("秒杀失败!");
        }
        if (o2Date.getTime() >= d1.getTime() && o2Date.getTime() <= d2.getTime()) {
            System.out.println("秒杀成功！");
        } else {
            System.out.println("秒杀失败!");
        }
    }
}

14、计算我至今活了多少时间

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.Period;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.util.Date;

public class DaysMeLive {
    public static void main(String[] args) throws ParseException {
        //jdk7
        String birthday = "1998-10-15";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthDate = sdf.parse(birthday);
        Date currentDate = new Date();

        System.out.println(birthDate);
        System.out.println(currentDate);
        System.out.println("time live: " + (currentDate.getTime() - birthDate.getTime())/1000/60/60/24);

        //jdk8
        LocalDate birth = LocalDate.of(1998, 10, 15);
        LocalDate current = LocalDate.now();
//        Period p = Period.between(birth, current);
        long days = ChronoUnit.DAYS.between(birth, current);
        System.out.println(days);

    }
}

15、冒泡排序

public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = {2, 4, 5, 3, 1};

        for (int j : arr) {
            System.out.print(j + " ");
        }

        System.out.println("\n===========================");

        bubbleSort(arr);

        System.out.print("Bubble sort Arr: ");
        for (int j : arr) {
            System.out.print(j + " ");
        }
    }

    private static void bubbleSort(int[] arr) {
        // 核心思想就是每一次内循环将最大值都放到数组最右端，需要arr.length - 1次外循环则可以将其变为有序列表
        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;
                }
            }
        }
    }
}

16、选择排序

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {2, 4, 5, 3, 1};

        for (int i : arr) {
            System.out.print(i + " ");
        }

        System.out.println("\n============================");

        selectSort(arr);

        System.out.print("Select sort Arr: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    private static void selectSort(int[] arr) {
        // 外层循环从0到数组倒数第二位
        for (int i = 0; i < arr.length - 1; i++) {
            // 每次循环j从i+1开始，直到数组最后一个元素
            for (int j = i + 1; j < arr.length; j++) {
                // 依次比较，若比当前i元素小则放置到i位置，即每一次外循环都将最小值放到有序列表的末尾
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

17、插入排序

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        for (int i : arr) {
            System.out.print(i + " ");
        }

        System.out.println("\n==============================");

        insertSort(arr);

        System.out.print("Insertion Sorted Array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    private static void insertSort(int[] arr) {
        // 首先假设第一个元素是有序的，将其作为有序列表，后面剩余元素作为无序列表
        for (int i = 1; i < arr.length; i++) {
            // 在有序列表中查找位置插入
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j + 1] < arr[j]) {
                    // j+1对应待插入元素下标，在有序列表中若发现待插入元素小于当前有序列表中的元素，则交换位置
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                } else {
                    // j+1待插入元素大于或等于当前有序列表中的元素j，找到位置，停止内循环，位置为j+1
                    break;
                }
            }
        }
    }
}

18、快速排序（快排）

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8}; //6 1 2 5 4 3 9 7 10 8 -> 9 1 2 5 4 3 6 7 10 8
        for (int i : arr) {
            System.out.print(i + " ");
        }

        System.out.println("\n==============================");

        quickSort(arr, 0, arr.length - 1);
        System.out.print("Quick Sorted Array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    private static void quickSort(int[] arr, int left, int right) {
        int basicIndex = left;
        int startIndex = left;
        int endIndex = right;

        if (left > right) {
            return;
        }

        while (startIndex < endIndex) {
            for (; endIndex > startIndex; endIndex--) {
                if (arr[endIndex] < arr[basicIndex]) {
                    break;
                }
            }

            for (; startIndex < endIndex; startIndex++) {
                if (arr[startIndex] > arr[basicIndex]) {
                    break;
                }

            }

            int tmp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = tmp;
        }

        int tmp = arr[basicIndex];
        arr[basicIndex] = arr[startIndex];
        arr[startIndex] = tmp;

        quickSort(arr, left, startIndex - 1);
        quickSort(arr, endIndex + 1, right);
    }
}

19、斐波那契数列

public class FibonacciList {
    public static void main(String[] args) {
        int num = 12;

        System.out.println("Fibonacci result: " + fibonacci(num));
    }

    public static int fibonacci(int n) {
        if (n == 1 || n == 2){
            return 1;
        }

        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

20、爬楼梯：小明每次可能跨一个阶梯或者两个阶梯，计算20层楼梯可能有哪些跨法

public class ClimbSteps {
    public static void main(String[] args) {
        int steps = 20;

        System.out.println("爬20层总方法数: " + methods(steps));
    }

    private static int methods(int steps) {
        if (steps == 1){
            return 1;
        }
        if (steps == 2){
            return 2;
        }

        return methods(steps - 1) + methods(steps - 2);
    }
}

21、猴子吃桃子：猴子第一天吃了所有桃子的一半还多一个，第二天吃剩下的一半还多一个，第10天发现只剩下1个桃子，问原来总共有多少？

public class MonkeyEatPeach {
    public static void main(String[] args) {
        int days = 10;

        System.out.println(func(10));
    }

    private static int func(int days) {
        if (days == 1) {
            return 1;
        }

        return 2 * (func(days - 1) + 1);
    }
}

22、使用递归函数求和

public class RecursiveFuncTest {
    public static void main(String[] args) {
        int num = 100;

        System.out.println(sum(num));
    }

    public static int sum(int num) {
        if (num == 0){
            return 0;
        }

        return num + sum(num - 1);
    }
}

23、使用递归函数计算一个数的阶乘

public class Factory {
    public static void main(String[] args) {
        int num = 5;

        System.out.println(factory(num));
    }

    private static int factory(int num) {
        if (num == 1){
            return 1;
        }

        return num * factory(num-1);
    }
}

24、重写Arrays库的比较方法（用lambda表达式），根据字符串的长度进行排序

import java.util.Arrays;

public class StringSort {
    public static void main(String[] args) {
        String[] strArr = {"a", "aaaa", "aaa", "aa"};

        Arrays.sort(strArr, (str1, str2) -> str1.length() - str2.length());

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

25、基本搜索方法：一是顺序遍历整个数组，查找到后返回；二是若存在重复也可以返回所有重复的值

import java.util.ArrayList;

public class BasicSearch {
    public static void main(String[] args) {
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};

        int num = 7;
        int index = basicSearch(arr, num);

        if (index == -1){
            System.out.println("Element not found");
        } else {
            System.out.println("Element found at index: " + index);
        }


        int[] arr2 = {131, 127, 147, 81, 127, 23, 7, 79};
        int num2 = 127;
        ArrayList<Integer> indices = basicSearchWithRepetition(arr2, num2);
        if (indices == null){
            System.out.println("Element not found");
        } else {
            System.out.print("Element found at index: ");
            for (int i = 0; i < indices.size(); i++) {
                System.out.print(indices.get(i) + " ");
            }
        }
    }

    private static int basicSearch(int[] arr, int num) {

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                return i;
            }
        }

        return -1;
    }

    private static ArrayList<Integer> basicSearchWithRepetition(int[] arr, int num) {
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                list.add(i);
            }
        }

        if (list.isEmpty()) {
            return null;
        } else {
            return list;
        }
    }
}

26、二分查找以及插值法查找：插值法其实就是在二分法之上计算一下查找值更可能在哪里，缩小范围，同时二分查找必须要求列表式有序的。

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};

        int num = 147;
        long startTime = new Date().getTime();
        System.out.println(startTime);
        int index = binarySearch(arr, num);

        if (index == -1){
            System.out.println("Element not found");
        } else {
            System.out.println("Element found at index: " + index + ", Time: " + (new Date().getTime() - startTime));
        }


        int num2 = 147;
        startTime = new Date().getTime();
        int index2 = interpolationSearch(arr, num2);

        if (index2 == -1){
            System.out.println("Element not found");
        } else {
            System.out.println("Element found at index: " + index2 + ", Time: " + (new Date().getTime() - startTime));
        }
    }

    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (target < arr[mid]) {
                right = mid - 1;
            } else if (target > arr[mid]) {
                left = mid + 1;
            }
        }

        return -1;
    }

    public static int interpolationSearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (target - arr[left]) / (arr[right] - arr[left]) * (right - left);
            if (arr[mid] == target) {
                return mid;
            } else if (target < arr[mid]) {
                right = mid - 1;
            } else if (target > arr[mid]) {
                left = mid + 1;
            }
        }

        return -1;
    }
}

27、分块查找就不在这里尝试了，它的核心思想就是把列表分块，每两块之间没有交集，块中无序，块间有序。分块数量一般是长度开根号。

28、哈希查找也不再尝试，它的核心思想就是在分块查找的基础上，用链表实现分块。