JavaSE之 常用 API 详解（附代码示例）

JavaSE之 常用 API 详解（附代码示例）

在 Java 开发中，API（Application Programming Interface）是提高开发效率的核心工具。本文整理了日常开发中最常用的 10大类API，包含核心功能、使用场景、代码示例，适合新手入门学习与开发参考。

一、Math 类：数学运算工具类

1. Math 类核心特点

• 概述：Java 提供的数学运算工具类，无需创建对象即可使用。
• 核心特点：
  • 构造方法私有（无法通过 new 创建对象）；
  • 所有成员方法均为静态方法（直接通过 Math.方法名() 调用）。

2. Math 类常用方法

3. 代码示例

package com.code.day14;

public class Day14Math {
    public static void main(String[] args) {
        // 1. 取绝对值
        System.out.println(Math.abs(-10)); // 输出：10
        System.out.println(Math.abs(10));  // 输出：10

        // 2. 向上取整
        System.out.println(Math.ceil(10.1));  // 输出：11.0
        System.out.println(Math.ceil(-5.2));  // 输出：-5.0

        // 3. 向下取整
        System.out.println(Math.floor(10.4)); // 输出：10.0
        System.out.println(Math.floor(-5.2)); // 输出：-6.0

        // 4. 四舍五入
        System.out.println(Math.round(10.4)); // 输出：10
        System.out.println(Math.round(10.5)); // 输出：11
        System.out.println(Math.round(-5.2)); // 输出：-5
        System.out.println(Math.round(-5.5)); // 输出：-5

        // 5. 最大值和最小值
        System.out.println(Math.max(10, 20)); // 输出：20
        System.out.println(Math.min(10, 20)); // 输出：10
    }
}

二、BigInteger 类：超大整数处理类

1. BigInteger 类核心场景

• 问题背景：long 是 Java 中能表示的最大基本整数类型（范围：-9223372036854775808 ~ 9223372036854775807），当需要处理超过 long 范围的整数时，需使用 BigInteger。
• 核心作用：处理任意大小的整数，无精度损失。

2. BigInteger 类常用方法

三、BigDecimal 类：高精度小数处理类

1. BigDecimal 类核心场景

• 问题背景：double 和 float 是浮点型，直接运算会出现精度损失（如 0.1 + 0.2 = 0.30000000000000004），BigDecimal 可解决此问题。
• 核心作用：处理高精度小数运算，避免精度损失。

2. BigDecimal 类常用方法

3. 关键说明：除法舍入模式

4. 代码示例

package com.code.day14;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Day14BigDecimal {
    public static void main(String[] args) {
        // 1. 创建 BigDecimal 对象（推荐 valueOf 或 String 构造）
        BigDecimal b1 = BigDecimal.valueOf(3.55);
        BigDecimal b2 = BigDecimal.valueOf(2.12);

        // 2. 加法
        BigDecimal add = b1.add(b2);
        System.out.println("加法结果：" + add); // 输出：5.67

        // 3. 减法
        BigDecimal subtract = b1.subtract(b2);
        System.out.println("减法结果：" + subtract); // 输出：1.43

        // 4. 乘法
        BigDecimal multiply = b1.multiply(b2);
        System.out.println("乘法结果：" + multiply); // 输出：7.5260

        // 5. 除法（指定保留 2 位小数，四舍五入）
        BigDecimal divide = b1.divide(b2, 2, RoundingMode.HALF_UP);
        System.out.println("除法结果：" + divide); // 输出：1.67
    }
}

四、Date 类：日期时间表示类

1. Date 类核心特点

• 概述：表示特定的瞬间，精确到毫秒。
• 关键常识：
  • 时间原点：1970年1月1日0时0分0秒（UTC时区）；
  • 北京时区：东8区，比时间原点快8小时；
  • 1秒 = 1000毫秒。

2. Date 类常用方法

3. 代码示例

package com.code.day14;
import java.util.Date;

public class Day14Date {
    public static void main(String[] args) {
        // 1. 创建表示当前时间的 Date 对象
        Date date = new Date();
        System.out.println("当前时间：" + date);

        // 2. 设置时间为“时间原点 + 1000毫秒”（即 1970-01-01 08:00:01）
        date.setTime(1000L);
        System.out.println("设置后的时间：" + date);

        // 3. 获取时间对应的毫秒值
        long timeMillis = date.getTime();
        System.out.println("对应的毫秒值：" + timeMillis); // 输出：1000
    }
}

五、Calendar 类：日历操作类

1. Calendar 类核心特点

• 概述：抽象类，用于操作日历字段（年、月、日、时、分、秒等），不能直接 new 对象，需通过静态方法获取实例。
• 关键注意：
  • 月份从 0 开始（0 = 1月，1 = 2月，…，11 = 12月）；
  • 每周从周日开始（0 = 周日，1 = 周一，…，6 = 周六）。

2. Calendar 类常用方法

3. 实战场景：判断闰年

package com.code.day14;

import java.util.Calendar;
import java.util.Scanner;

public class Day14CalendarKuoZhan {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个年份：");
        int year = scanner.nextInt();

        // 1. 获取 Calendar 实例
        Calendar calendar = Calendar.getInstance();

        // 2. 设置时间为“输入年份的 3月1日”（3月对应月份值为 2）
        calendar.set(year, 2, 1);

        // 3. 减 1 天 → 得到 2月的最后一天
        calendar.add(Calendar.DATE, -1);

        // 4. 获取 2月最后一天的日期（若为 29，则是闰年）
        int day = calendar.get(Calendar.DATE);
        if (day == 29) {
            System.out.println(year + "是闰年");
        } else {
            System.out.println(year + "不是闰年");
        }

        scanner.close();
    }
}

六、SimpleDateFormat 类：日期格式化类

1. SimpleDateFormat 类核心作用

• 概述：DateFormat 的子类，用于实现 Date 对象与字符串的相互转换。
• 核心功能：
  • 格式化（Format）：将 Date 对象按指定格式转为字符串；
  • 解析（Parse）：将符合格式的字符串转为 Date 对象。

2. 关键：日期格式占位符

注意：连接符可自定义（如 -、/、年、月 等），但占位符不可变（如年份必须用 yyyy，不能用 xxxx）。

3. 代码示例

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

public class Day14SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        // 1. 格式化：Date → String
        Date now = new Date();
        // 指定格式：yyyy-MM-dd HH:mm:ss
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf1.format(now);
        System.out.println("格式化后的日期：" + dateStr); // 示例：2024-09-03 14:30:59

        // 2. 解析：String → Date（字符串格式必须与指定格式一致，否则抛 ParseException）
        String targetStr = "2019-10-10 10:10:10";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date targetDate = sdf2.parse(targetStr);
        System.out.println("解析后的 Date 对象：" + targetDate); // 示例：Thu Oct 10 10:10:10 CST 2019
    }
}

七、JDK8 新日期类（LocalDate/LocalDateTime 等）

JDK8 之前的 Date 和 Calendar 存在线程不安全、API 设计混乱等问题，因此新增了 java.time 包，包含 LocalDate、LocalDateTime、Period、Duration、DateTimeFormatter 等类，解决了旧 API 的缺陷。

1. LocalDate：日期（年月日）

1.1 核心方法

1.2 代码示例

package com.code.day14;

import java.time.LocalDate;

public class Day14LocalDate {
    public static void main(String[] args) {
        // 1. 获取当前日期
        LocalDate now = LocalDate.now();
        System.out.println("当前日期：" + now); // 示例：2024-09-03

        // 2. 创建指定日期（2020年10月10日）
        LocalDate targetDate = LocalDate.of(2020, 10, 10);
        System.out.println("指定日期：" + targetDate); // 输出：2020-10-10

        // 3. 修改日期（修改为 2024年10月10日）
        LocalDate modifiedDate = now.withYear(2024).withMonth(10).withDayOfMonth(10);
        System.out.println("修改后日期：" + modifiedDate); // 输出：2024-10-10

        // 4. 增减年份（当前日期加 1 年）
        LocalDate nextYear = now.plusYears(1);
        System.out.println("明年今日：" + nextYear); // 示例：2025-09-03
    }
}

2. LocalDateTime：日期时间（年月日时分秒）

2.1 核心方法

2.2 代码示例

package com.code.day14;

import java.time.LocalDateTime;

public class Day14LocalDateTime {
    public static void main(String[] args) {
        // 1. 获取当前日期时间
        LocalDateTime now = LocalDateTime.now();
        System.out.println("当前日期时间：" + now); // 示例：2024-09-03T15:40:30.123

        // 2. 创建指定日期时间（2020年10月10日10时10分10秒）
        LocalDateTime targetTime = LocalDateTime.of(2020, 10, 10, 10, 10, 10);
        System.out.println("指定日期时间：" + targetTime); // 输出：2020-10-10T10:10:10

        // 3. 增减时间（加2小时，减30分钟）
        LocalDateTime modifiedTime = targetTime.plusHours(2).minusMinutes(30);
        System.out.println("修改后时间：" + modifiedTime); // 输出：2020-10-10T11:40:10
    }
}

3. Period & Duration：日期/时间差值计算

3.1 Period：计算日期差值（年月日）

• 核心作用：计算两个 LocalDate 之间的差值，返回年、月、日的具体差值。
• 常用方法：
  • static Period between(LocalDate start, LocalDate end)：计算 start 到 end 的日期差（end 需在 start 之后，否则差值为负）；
  • int getYears()：获取相差的年数；
  • int getMonths()：获取相差的月数；
  • int getDays()：获取相差的天数。

3.2 Duration：计算时间差值（时分秒毫秒）

• 核心作用：计算两个 LocalDateTime（或 LocalTime）之间的差值，返回天、时、分、秒、毫秒的具体差值。
• 常用方法：
  • static Duration between(Temporal start, Temporal end)：计算 start 到 end 的时间差；
  • long toDays()：转换为相差的天数；
  • long toHours()：转换为相差的小时数；
  • long toMinutes()：转换为相差的分钟数；
  • long toMillis()：转换为相差的毫秒数。

3.3 代码示例

package com.code.day14;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;

public class Day14PeriodDuration {
    public static void main(String[] args) {
        // ------------------- Period：计算日期差 -------------------
        LocalDate date1 = LocalDate.of(2024, 10, 10);
        LocalDate date2 = LocalDate.of(2025, 11, 12);
        Period period = Period.between(date1, date2);
        System.out.println("日期差：" + period.getYears() + "年" + period.getMonths() + "月" + period.getDays() + "天");
        // 输出：日期差：1年1月2天

        // ------------------- Duration：计算时间差 -------------------
        LocalDateTime time1 = LocalDateTime.of(2020, 1, 1, 0, 0);
        LocalDateTime time2 = LocalDateTime.of(2022, 1, 1, 1, 1);
        Duration duration = Duration.between(time1, time2);
        System.out.println("时间差：" + duration.toDays() + "天 " + (duration.toHours() % 24) + "小时 " + (duration.toMinutes() % 60) + "分钟");
        // 输出：时间差：731天 1小时 1分钟
    }
}

4. DateTimeFormatter：日期时间格式化（JDK8+）

• 核心作用：替代 JDK8 之前的 SimpleDateFormat，线程安全，用于 LocalDate/LocalDateTime 与字符串的相互转换。
• 常用方法：
  • static DateTimeFormatter ofPattern(String pattern)：指定格式创建 DateTimeFormatter 对象（格式占位符与 SimpleDateFormat 一致，如 yyyy-MM-dd HH:mm:ss）；
  • String format(TemporalAccessor temporal)：将日期时间对象（如 LocalDateTime）格式化为字符串；
  • TemporalAccessor parse(CharSequence text)：将符合格式的字符串解析为 TemporalAccessor，再通过 LocalDateTime.from() 转为目标对象。

代码示例

package com.code.day14;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;

public class Day14DateTimeFormatter {
    public static void main(String[] args) {
        // 1. 格式化：LocalDateTime → String
        LocalDateTime now = LocalDateTime.of(2019, 10, 10, 10, 10, 10);
        // 指定格式
        DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String timeStr = formatter1.format(now);
        System.out.println("格式化结果：" + timeStr); // 输出：2019-10-10 10:10:10

        // 2. 解析：String → LocalDateTime
        String targetStr = "2019-10-10 10:10:10";
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 先解析为 TemporalAccessor，再转为 LocalDateTime
        TemporalAccessor temporal = formatter2.parse(targetStr);
        LocalDateTime parsedTime = LocalDateTime.from(temporal);
        System.out.println("解析结果：" + parsedTime); // 输出：2019-10-10T10:10:10

        // 简化解析方式（直接通过 LocalDateTime.parse() 重载方法）
        LocalDateTime simplifiedParsed = LocalDateTime.parse(targetStr, formatter2);
        System.out.println("简化解析结果：" + simplifiedParsed); // 输出：2019-10-10T10:10:10
    }
}

八、System 类：系统工具类

1. System 类核心特点

• 概述：与系统交互的工具类，提供系统级别的操作。
• 核心特点：
  • 构造方法私有（无法 new 对象）；
  • 所有方法均为静态方法（通过 System.方法名() 调用）。

2. System 类常用方法

3. 代码示例

package com.code.day14;

import java.util.Date;

public class Day14System {
    public static void main(String[] args) {
        // 1. 获取当前系统时间毫秒值
        long currentTime = System.currentTimeMillis();
        System.out.println("当前时间毫秒值：" + currentTime);
        // 转为 Date 对象查看
        Date nowDate = new Date(currentTime);
        System.out.println("当前时间：" + nowDate); // 示例：Tue Sep 03 16:05:23 CST 2024

        // 2. 数组复制（将 src 数组的内容复制到 dest 数组）
        int[] src = {1, 2, 3, 4, 5};
        int[] dest = new int[src.length];
        // 参数含义：源数组、源数组起始索引、目标数组、目标数组起始索引、复制长度
        System.arraycopy(src, 0, dest, 0, src.length);
        System.out.print("复制后的目标数组：");
        for (int num : dest) {
            System.out.print(num + " "); // 输出：1 2 3 4 5 
        }

        // 3. 退出JVM（注释掉避免影响后续代码执行）
        // System.exit(0);
        // System.out.println("此代码不会执行（JVM已退出）");
    }
}

九、Arrays 类：数组工具类

1. Arrays 类核心作用

• 概述：专门用于操作数组的工具类，提供排序、查找、复制、打印等常用功能。
• 核心特点：
  • 构造方法私有；
  • 方法均为静态方法。

2. Arrays 类常用方法

3. 代码示例

package com.code.day14;

import java.util.Arrays;

public class Day14Arrays {
    public static void main(String[] args) {
        // 1. 数组打印（toString()）
        int[] arr1 = {1, 2, 3, 4, 5};
        System.out.println("arr1 原始值：" + Arrays.toString(arr1)); // 输出：[1, 2, 3, 4, 5]

        // 2. 数组排序（sort()）
        int[] arr2 = {5, 3, 1, 4, 2};
        Arrays.sort(arr2);
        System.out.println("arr2 排序后：" + Arrays.toString(arr2)); // 输出：[1, 2, 3, 4, 5]

        // 3. 二分查找（binarySearch()，需先排序）
        int[] arr3 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int index = Arrays.binarySearch(arr3, 5);
        System.out.println("元素 5 在 arr3 中的索引：" + index); // 输出：4（索引从0开始）
        // 查找不存在的元素（返回负数）
        int noIndex = Arrays.binarySearch(arr3, 11);
        System.out.println("元素 11 在 arr3 中的索引：" + noIndex); // 输出：-11

        // 4. 数组扩容（copyOf()）
        int[] arr4 = {1, 2, 3, 4, 5};
        // 扩容为原长度的2倍（不足部分补0）
        int[] newArr = Arrays.copyOf(arr4, arr4.length * 2);
        System.out.println("arr4 扩容后：" + Arrays.toString(newArr)); // 输出：[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
    }
}

十、包装类：基本类型与引用类型的桥梁

1. 包装类概述

• 定义：为 8 种基本类型提供对应的 引用类型（包装类），解决“集合只能存储引用类型”“方法参数需引用类型”等问题。
• 基本类型与包装类对应关系：

2. Integer 类核心使用（以 Integer 为例，其他包装类用法类似）

2.1 构造/创建方式（JDK9+ 推荐）

JDK9 之前的 new Integer(int) 和 new Integer(String) 已过时，推荐使用 静态工厂方法 valueOf()：

• static Integer valueOf(int i)：将 int 转为 Integer；
• static Integer valueOf(String s)：将字符串格式的整数转为 Integer（字符串需为纯数字，否则抛 NumberFormatException）。

2.2 装箱与拆箱

• 装箱：基本类型 → 包装类（手动：Integer.valueOf(100)；自动：Integer i = 100，编译器自动调用 valueOf()）；
• 拆箱：包装类 → 基本类型（手动：i.intValue()；自动：int num = i，编译器自动调用 intValue()）。

2.3 关键：Integer 缓存机制(笔试题)

Integer.valueOf() 会缓存 -128 ~ 127 范围内的 Integer 对象，避免重复创建，提升性能：

• 当值在 -128~127 时，多次调用 valueOf() 返回同一个对象（== 比较为 true）；
• 当值超出范围时，每次调用 valueOf() 创建新对象（== 比较为 false）。

3. 代码示例

package com.code.day14;

public class Day14Integer {
    public static void main(String[] args) {
        // 1. JDK9+ 创建 Integer 对象（valueOf()）
        Integer i1 = Integer.valueOf(100);
        Integer i2 = Integer.valueOf("100");
        System.out.println("i1 = " + i1); // 输出：100
        System.out.println("i2 = " + i2); // 输出：100

        // 2. 自动装箱与拆箱
        Integer i3 = 200; // 自动装箱（等价于 Integer.valueOf(200)）
        int num = i3;     // 自动拆箱（等价于 i3.intValue()）
        System.out.println("num = " + (num + 50)); // 输出：250（拆箱后可直接参与运算）

        // 3. Integer 缓存机制验证
        Integer a = 100; // 在缓存范围内（-128~127）
        Integer b = 100;
        System.out.println("a == b：" + (a == b)); // 输出：true（同一对象）

        Integer c = 200; // 超出缓存范围
        Integer d = 200;
        System.out.println("c == d：" + (c == d)); // 输出：false（不同对象）
        System.out.println("c.equals(d)：" + c.equals(d)); // 输出：true（equals() 比较值）
    }
}

总结

本文整理的 10 大类 API 是 Java 开发的基础工具，涵盖 数学运算、高精度数值、日期时间、系统操作、数组处理、类型转换 等核心场景。建议重点掌握：

1. JDK8 新日期类（LocalDate/LocalDateTime/DateTimeFormatter），替代旧的 Date/Calendar；
2. 包装类的自动装箱/拆箱与缓存机制（面试高频）；
3. BigDecimal 的高精度运算（金融、电商等场景必备）；
4. Arrays 与 System 类的实用方法（提升开发效率）。

实际开发中，需结合场景选择合适的 API，并注意异常处理（如 BigDecimal 除法、Integer.valueOf(String) 解析），确保代码健壮性。