Java 常用 API 与字符串、时间处理

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.abs(-18));
        System.out.println(Math.ceil(3.14));
        System.out.println(Math.floor(3.99));
        System.out.println(Math.round(4.5));
        System.out.println(Math.pow(2, 10));
        System.out.println(Math.sqrt(81));
    }
}

(int) (Math.random() * 个数) + 起始值

public class RandomDemo {
    public static void main(String[] args) {
        int number = (int) (Math.random() * 100) + 1;
        System.out.println(number); // 1 到 100
    }
}

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomDemo {
    public static void main(String[] args) {
        int number = ThreadLocalRandom.current().nextInt(1, 101);
        System.out.println(number);
    }
}

public class TimeMillisDemo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

        long sum = 0;
        for (int i = 1; i <= 1000000; i++) {
            sum += i;
        }

        long end = System.currentTimeMillis();
        System.out.println("求和结果：" + sum);
        System.out.println("耗时：" + (end - start) + " 毫秒");
    }
}

import java.util.Arrays;

public class ArrayCopyDemo {
    public static void main(String[] args) {
        int[] source = {10, 20, 30, 40, 50};
        int[] target = new int[5];

        System.arraycopy(source, 1, target, 0, 3);
        System.out.println(Arrays.toString(target)); // [20, 30, 40, 0, 0]
    }
}

System.arraycopy(源数组, 源数组起始索引, 目标数组, 目标数组起始索引, 拷贝个数);

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

public class WrapperNeedDemo {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);
        scores.add(88);
        System.out.println(scores);
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        Integer a = 100; // 自动装箱，等价于 Integer.valueOf(100)
        int b = a;       // 自动拆箱，等价于 a.intValue()

        System.out.println(a);
        System.out.println(b);
    }
}

public class UnboxNullDemo {
    public static void main(String[] args) {
        Integer count = null;
        // int result = count; // 自动拆箱时会调用 count.intValue()
    }
}

public class ParseDemo {
    public static void main(String[] args) {
        int age = Integer.parseInt("18");
        double price = Double.parseDouble("19.9");
        boolean enabled = Boolean.parseBoolean("true");

        System.out.println(age + 1);
        System.out.println(price);
        System.out.println(enabled);
    }
}

String s1 = Integer.toString(100);
String s2 = String.valueOf(200);
String s3 = 300 + "";

public class IntegerCacheDemo {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        Integer c = 128;
        Integer d = 128;

        System.out.println(a == b); // true
        System.out.println(c == d); // false
        System.out.println(c.equals(d)); // true
    }
}

public class DoubleProblemDemo {
    public static void main(String[] args) {
        System.out.println(0.1 + 0.2); // 0.30000000000000004
    }
}

import java.math.BigDecimal;

public class BigDecimalCreateDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b = new BigDecimal("0.2");
        System.out.println(a.add(b)); // 0.3
    }
}

BigDecimal value = new BigDecimal(0.1);

BigDecimal value = BigDecimal.valueOf(0.1);

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

public class BigDecimalCalculateDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("10.00");
        BigDecimal b = new BigDecimal("3.00");

        System.out.println(a.add(b));
        System.out.println(a.subtract(b));
        System.out.println(a.multiply(b));
        System.out.println(a.divide(b, 2, RoundingMode.HALF_UP));
    }
}

import java.math.BigDecimal;

public class BigDecimalCompareDemo {
    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("1.00");

        System.out.println(a.equals(b)); // false
        System.out.println(a.compareTo(b) == 0); // true
    }
}

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

public class MoneyUtils {
    /**
     * 计算商品总价，并按金额常见规则保留两位小数。
     *
     * @param price 商品单价，不能为 null
     * @param count 商品数量
     * @return 保留两位小数后的总价
     */
    public static BigDecimal calculateTotal(BigDecimal price, int count) {
        if (price == null) {
            throw new IllegalArgumentException("商品单价不能为空");
        }
        if (count < 0) {
            throw new IllegalArgumentException("商品数量不能为负数");
        }

        // 关键业务逻辑：金额计算统一在最后一步做舍入，避免中间过程过早丢失精度。
        return price.multiply(BigDecimal.valueOf(count))
                .setScale(2, RoundingMode.HALF_UP);
    }
}

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 9, 1, 3};

        System.out.println(Arrays.toString(numbers));

        Arrays.sort(numbers);
        System.out.println(Arrays.toString(numbers));

        System.out.println(Arrays.binarySearch(numbers, 3));
    }
}

import java.util.Arrays;

public class ArraysCopyDemo {
    public static void main(String[] args) {
        int[] oldArray = {10, 20, 30};
        int[] newArray = Arrays.copyOf(oldArray, 5);

        System.out.println(Arrays.toString(newArray)); // [10, 20, 30, 0, 0]

        int[] rangeArray = Arrays.copyOfRange(oldArray, 1, 3);
        System.out.println(Arrays.toString(rangeArray)); // [20, 30]

        Arrays.fill(newArray, 99);
        System.out.println(Arrays.toString(newArray));
    }
}

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

public class StudentSortDemo {
    public static void main(String[] args) {
        Student[] students = {
                new Student("张三", 18),
                new Student("李四", 20),
                new Student("王五", 19)
        };

        Arrays.sort(students, Comparator.comparingInt(Student::getAge));
        System.out.println(Arrays.toString(students));
    }
}

class Student {
    private final String name;
    private final int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + ":" + age;
    }
}

import java.util.Arrays;
import java.util.List;

public class AsListDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        names.set(0, "赵六");
        System.out.println(names);

        // names.add("小明"); // UnsupportedOperationException
    }
}

int[] numbers = {1, 2, 3};
System.out.println(Arrays.asList(numbers).size()); // 1

String result1 = String.join(", ", "Java", "Spring", "MySQL");
System.out.println(result1); // Java, Spring, MySQL

import java.util.List;

List<String> names = List.of("张三", "李四", "王五");
String result2 = String.join(" | ", names);
System.out.println(result2); // 张三 | 李四 | 王五

import java.util.StringJoiner;

StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("张三");
joiner.add("李四");
joiner.add("王五");

System.out.println(joiner.toString()); // [张三, 李四, 王五]

String msg = String.format("用户 %s 的成绩是 %d 分", "小明", 95);
System.out.println(msg);

String priceText = String.format("价格：%.2f 元", 19.986);
System.out.println(priceText); // 价格：19.99 元

String msg = "用户 %s 的成绩是 %d 分".formatted("小明", 95);
System.out.println(msg);

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date now = new Date();
        Date start = new Date(0L);

        System.out.println(now);
        System.out.println(start);
        System.out.println(now.getTime());
    }
}

import java.util.Date;

public class DateTimeDemo {
    public static void main(String[] args) {
        Date date = new Date();
        long time = date.getTime();

        date.setTime(time + 24 * 60 * 60 * 1000L);
        System.out.println(date);
    }
}

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String text = format.format(new Date());
        System.out.println(text);

        Date date = format.parse("2026-05-14 21:30:00");
        System.out.println(date);
    }
}

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalDateTimeDemo {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        LocalTime nowTime = LocalTime.now();
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime custom = LocalDateTime.of(2026, 5, 14, 21, 30, 10);

        System.out.println(today);
        System.out.println(nowTime);
        System.out.println(now);
        System.out.println(custom.getYear());
        System.out.println(custom.getMonthValue());
        System.out.println(custom.getDayOfMonth());
        System.out.println(custom.getHour());
    }
}

import java.time.LocalDateTime;

public class ImmutableDateTimeDemo {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime nextWeek = now.plusWeeks(1);

        System.out.println(now);
        System.out.println(nextWeek);
    }
}

import java.time.LocalDateTime;

public class PlusMinusDemo {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.of(2026, 5, 14, 21, 30);

        System.out.println(now.plusYears(1));
        System.out.println(now.plusMonths(2));
        System.out.println(now.plusDays(10));
        System.out.println(now.minusHours(3));
    }
}

import java.time.LocalDateTime;

public class WithDemo {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.of(2026, 5, 14, 21, 30);

        LocalDateTime firstDay = now.withDayOfMonth(1);
        LocalDateTime startOfDay = now.withHour(0).withMinute(0).withSecond(0).withNano(0);

        System.out.println(firstDay);
        System.out.println(startOfDay);
    }
}

import java.time.LocalDateTime;

public class CompareDateTimeDemo {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2026, 5, 14, 9, 0);
        LocalDateTime end = LocalDateTime.of(2026, 5, 14, 18, 0);

        System.out.println(start.isBefore(end));
        System.out.println(end.isAfter(start));
        System.out.println(start.isEqual(end));
    }
}

import java.time.LocalDateTime;

public class ActivityTimeUtils {
    /**
     * 根据活动开始时间和持续天数计算活动结束时间。
     *
     * @param start 活动开始时间，不能为 null
     * @param days 持续天数，必须大于 0
     * @return 活动结束时间
     */
    public static LocalDateTime calculateEndTime(LocalDateTime start, int days) {
        if (start == null) {
            throw new IllegalArgumentException("活动开始时间不能为空");
        }
        if (days <= 0) {
            throw new IllegalArgumentException("持续天数必须大于 0");
        }

        // 关键业务逻辑：活动持续 N 天时，结束时间按开始时间向后推 N 天计算。
        return start.plusDays(days);
    }
}

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

public class DateTimeFormatterDemo {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.of(2026, 5, 14, 21, 30, 10);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        String text = now.format(formatter);
        LocalDateTime parsed = LocalDateTime.parse(text, formatter);

        System.out.println(text);
        System.out.println(parsed);
    }
}

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitDemo {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2026, 5, 1, 8, 0);
        LocalDateTime end = LocalDateTime.of(2026, 5, 14, 21, 30);

        System.out.println(ChronoUnit.DAYS.between(start, end));
        System.out.println(ChronoUnit.HOURS.between(start, end));
        System.out.println(ChronoUnit.MINUTES.between(start, end));
    }
}

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class OrderTimeoutUtils {
    /**
     * 判断订单是否已经超过指定分钟数未支付。
     *
     * @param createTime 订单创建时间，不能为 null
     * @param currentTime 当前时间，不能为 null
     * @param timeoutMinutes 超时时长，单位分钟
     * @return 已超时返回 true，否则返回 false
     */
    public static boolean isPaymentTimeout(LocalDateTime createTime, LocalDateTime currentTime, long timeoutMinutes) {
        if (createTime == null || currentTime == null) {
            throw new IllegalArgumentException("时间参数不能为空");
        }
        if (timeoutMinutes <= 0) {
            throw new IllegalArgumentException("超时时长必须大于 0");
        }

        long minutes = ChronoUnit.MINUTES.between(createTime, currentTime);
        return minutes >= timeoutMinutes;
    }
}