标准库深度挖掘：90%开发者不知道的实用函数

🎓博主介绍：精通 C、Python、Java、JavaScript 等编程语言，具备全栈开发能力。日常专注于分享编程干货、算法解析、项目实战经验，以及前沿技术动态。让我们一起在技术的道路上不断探索，共同成长！

标准库深度挖掘：90%开发者不知道的实用函数

1. 引言

在编程的世界里，标准库就像是一座宝藏，里面蕴藏着无数实用的工具和功能。大多数开发者对标准库中的常见函数都比较熟悉，然而，还有许多强大且实用的函数隐藏在标准库的深处，等待我们去发现。本文将深入挖掘标准库，为大家介绍一些 90% 开发者可能不知道的实用函数，帮助大家提升编程效率和代码质量。

2. C 语言标准库中的实用函数

2.1 strtok：字符串分割利器

strtok 函数用于将一个字符串分割成多个标记（tokens）。

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello,World,How,Are,You";
    char *token;

    // 获取第一个标记
    token = strtok(str, ",");
    while (token != NULL) {
        printf("%s\n", token);
        // 获取下一个标记
        token = strtok(NULL, ",");
    }

    return 0;
}

步骤解析：

1. 定义一个包含分隔符的字符串 str。
2. 调用 strtok 函数，第一个参数是要分割的字符串，第二个参数是分隔符字符串。第一次调用时，传入原始字符串。
3. 使用 while 循环，只要 token 不为 NULL，就打印当前标记，并继续调用 strtok 函数获取下一个标记。后续调用时，第一个参数传入 NULL，表示继续从上次分割的位置开始。

2.2 qsort：通用排序函数

qsort 是一个通用的排序函数，可以对任何类型的数组进行排序。

#include <stdio.h>
#include <stdlib.h>

// 比较函数，用于比较两个整数的大小
int compare(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

int main() {
    int arr[] = {5, 3, 8, 4, 2};
    int n = sizeof(arr) / sizeof(arr[0]);

    // 调用 qsort 函数进行排序
    qsort(arr, n, sizeof(int), compare);

    // 输出排序后的数组
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

步骤解析：

1. 定义一个比较函数 compare，该函数接受两个 const void * 类型的参数，需要将其转换为实际类型进行比较。返回值为负数表示第一个元素小于第二个元素，为 0 表示相等，为正数表示第一个元素大于第二个元素。
2. 定义一个数组 arr 并初始化。
3. 调用 qsort 函数，第一个参数是要排序的数组，第二个参数是数组元素的数量，第三个参数是每个元素的大小，第四个参数是比较函数。
4. 输出排序后的数组。

2.3 mktime：时间转换神器

mktime 函数用于将 struct tm 结构体表示的时间转换为自 1970 年 1 月 1 日以来的秒数。

#include <stdio.h>
#include <time.h>

int main() {
    struct tm time_info;
    time_info.tm_year = 2024 - 1900;  // 年份从 1900 开始计算
    time_info.tm_mon = 9;  // 月份从 0 开始计算
    time_info.tm_mday = 1;
    time_info.tm_hour = 12;
    time_info.tm_min = 0;
    time_info.tm_sec = 0;
    time_info.tm_isdst = -1;  // 自动确定是否为夏令时

    // 调用 mktime 函数进行时间转换
    time_t timestamp = mktime(&time_info);

    if (timestamp != (time_t)-1) {
        printf("转换后的时间戳: %ld\n", (long)timestamp);
    } else {
        printf("时间转换失败\n");
    }

    return 0;
}

步骤解析：

1. 定义一个 struct tm 结构体 time_info，并初始化各个时间字段。
2. 将 tm_isdst 字段设置为 -1，表示自动确定是否为夏令时。
3. 调用 mktime 函数，传入 time_info 的地址，将返回的时间戳存储在 timestamp 中。
4. 检查 timestamp 是否为 -1，如果不是，则输出转换后的时间戳；否则，输出转换失败信息。

3. Python 标准库中的实用函数

3.1 functools.lru_cache：缓存装饰器

functools.lru_cache 是一个装饰器，用于实现最近最少使用（LRU）缓存机制，可以显著提高递归函数或重复计算函数的性能。

import functools

@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# 测试
result = fibonacci(10)
print(f"斐波那契数列的第 10 项是: {result}")

步骤解析：

1. 导入 functools 模块。
2. 定义一个递归的斐波那契数列函数 fibonacci。
3. 使用 @functools.lru_cache(maxsize=128) 装饰器对 fibonacci 函数进行装饰，maxsize 参数指定缓存的最大条目数。
4. 调用 fibonacci 函数计算第 10 项的值并输出。

3.2 itertools.product：笛卡尔积生成器

itertools.product 函数用于生成多个可迭代对象的笛卡尔积。

import itertools

# 定义两个可迭代对象
list1 = [1, 2, 3]
list2 = ['a', 'b']

# 生成笛卡尔积
product_result = itertools.product(list1, list2)

# 输出结果
for item in product_result:
    print(item)

步骤解析：

1. 导入 itertools 模块。
2. 定义两个可迭代对象 list1 和 list2。
3. 调用 itertools.product 函数，传入这两个可迭代对象，返回一个生成器对象。
4. 使用 for 循环遍历生成器对象，输出笛卡尔积的每个元素。

3.3 collections.Counter：计数器工具

collections.Counter 是一个简单而强大的计数器工具，用于统计可迭代对象中元素的出现次数。

from collections import Counter

# 定义一个列表
words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']

# 创建 Counter 对象
counter = Counter(words)

# 输出每个元素的出现次数
for word, count in counter.items():
    print(f"{word}: {count}")

步骤解析：

1. 从 collections 模块导入 Counter 类。
2. 定义一个列表 words。
3. 创建 Counter 对象，传入 words 列表，它会自动统计每个元素的出现次数。
4. 使用 for 循环遍历 Counter 对象的 items 方法，输出每个元素及其出现次数。

4. Java 标准库中的实用函数

4.1 java.util.Base64：Base64 编解码

java.util.Base64 类提供了 Base64 编码和解码的功能。

import java.util.Base64;

public class Base64Example {
    public static void main(String[] args) {
        String originalString = "Hello, World!";

        // 编码
        String encodedString = Base64.getEncoder().encodeToString(originalString.getBytes());
        System.out.println("编码后的字符串: " + encodedString);

        // 解码
        byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("解码后的字符串: " + decodedString);
    }
}

步骤解析：

1. 导入 java.util.Base64 类。
2. 定义一个原始字符串 originalString。
3. 使用 Base64.getEncoder().encodeToString() 方法对原始字符串的字节数组进行编码，得到编码后的字符串。
4. 使用 Base64.getDecoder().decode() 方法对编码后的字符串进行解码，得到解码后的字节数组。
5. 将解码后的字节数组转换为字符串并输出。

4.2 java.util.Collections.reverse：列表反转

java.util.Collections.reverse 方法用于反转列表中的元素顺序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListReverseExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("反转前的列表: " + list);

        // 反转列表
        Collections.reverse(list);

        System.out.println("反转后的列表: " + list);
    }
}

步骤解析：

1. 导入 java.util.ArrayList、java.util.Collections 和 java.util.List 类。
2. 创建一个 ArrayList 对象并添加一些元素。
3. 输出反转前的列表。
4. 调用 Collections.reverse 方法，传入列表对象，对列表进行反转。
5. 输出反转后的列表。

4.3 java.time.Duration：时间间隔计算

java.time.Duration 类用于表示两个时间点之间的时间间隔。

import java.time.Duration;
import java.time.LocalTime;

public class DurationExample {
    public static void main(String[] args) {
        LocalTime startTime = LocalTime.of(9, 0);
        LocalTime endTime = LocalTime.of(10, 30);

        // 计算时间间隔
        Duration duration = Duration.between(startTime, endTime);

        System.out.println("时间间隔: " + duration.toMinutes() + " 分钟");
    }
}

步骤解析：

1. 导入 java.time.Duration 和 java.time.LocalTime 类。
2. 创建两个 LocalTime 对象 startTime 和 endTime，分别表示开始时间和结束时间。
3. 调用 Duration.between 方法，传入开始时间和结束时间，得到一个 Duration 对象。
4. 使用 toMinutes 方法获取时间间隔的分钟数并输出。

5. 结论

标准库中隐藏着许多实用的函数，它们可以帮助我们更高效地完成编程任务。通过深入挖掘标准库，我们可以发现这些宝藏函数，提升代码的质量和性能。希望本文介绍的这些函数能够为你在编程过程中带来便利，让你在开发中更加得心应手。