新日期时间API详解

// 当前时间
LocalDate today = LocalDate.now();
LocalTime now = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.now();
ZonedDateTime zonedNow = ZonedDateTime.now();  // 使用系统默认时区
Instant instant = Instant.now();               // UTC 时间戳

// 指定值创建
LocalDate date = LocalDate.of(2024, 3, 15);       // 2024-03-15
LocalTime time = LocalTime.of(14, 30, 0);          // 14:30:00
LocalDateTime dt = LocalDateTime.of(2024, 3, 15, 14, 30);
ZonedDateTime zdt = ZonedDateTime.of(dt, ZoneId.of("Asia/Shanghai"));
Instant instant2 = Instant.ofEpochSecond(1710484800);

// 字符串解析
LocalDate parsed = LocalDate.parse("2024-03-15");
LocalDateTime parsedDt = LocalDateTime.parse("2024-03-15T14:30:00");

// plus/minus 运算
LocalDate nextWeek = today.plusWeeks(1);
LocalDate lastMonth = today.minusMonths(1);
LocalDateTime plusHours = dateTime.plusHours(3).minusMinutes(30);

// with 运算（设置指定字段）
LocalDate firstOfMonth = today.withDayOfMonth(1);       // 本月第一天
LocalDate lastOfYear = today.with(TemporalAdjusters.lastDayOfYear());

// 日期比较
boolean isAfter = date1.isAfter(date2);
boolean isBefore = date1.isBefore(date2);

// Period：日期层面的差异（年、月、日）
Period period = Period.between(
    LocalDate.of(2024, 1, 1),
    LocalDate.of(2024, 3, 15)
);  // P2M14D

// Duration：时间层面的差异（秒、纳秒）
Duration duration = Duration.between(
    LocalTime.of(9, 0),
    LocalTime.of(17, 30)
);  // PT8H30M

// java.util.Date → java.time
Instant instant = oldDate.toInstant();
ZonedDateTime zdt = instant.atZone(ZoneId.systemDefault());
LocalDateTime ldt = zdt.toLocalDateTime();

// java.time → java.util.Date
Date newDate = Date.from(instant);
// LocalDateTime → Date 需要先附加时区
Date date = Date.from(ldt.atZone(ZoneId.systemDefault()).toInstant());

// java.util.Calendar → java.time
Instant instant2 = calendar.toInstant();

// 预定义格式器
DateTimeFormatter.ISO_LOCAL_DATE;       // 2024-03-15
DateTimeFormatter.ISO_LOCAL_DATE_TIME;  // 2024-03-15T14:30:00
DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);  // 2024年3月15日 星期五

// 自定义格式
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String formatted = LocalDateTime.now().format(formatter);
LocalDateTime parsed = LocalDateTime.parse("2024年03月15日 14:30:00", formatter);

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.*;

/**
 * 飞翔科技全球办公时区转换系统
 * 演示 ZonedDateTime、ZoneId、时区转换
 */
public class FeixiangTimeZoneDemo {
    public static void main(String[] args) {
        System.out.println("========== 飞翔科技全球办公时区转换 ==========\n");

        // 飞翔科技的全球办公室
        Map<String, ZoneId> offices = new LinkedHashMap<>();
        offices.put("北京总部", ZoneId.of("Asia/Shanghai"));       // UTC+8
        offices.put("深圳研发中心", ZoneId.of("Asia/Shanghai"));   // UTC+8
        offices.put("东京办事处", ZoneId.of("Asia/Tokyo"));        // UTC+9
        offices.put("新加坡分部", ZoneId.of("Asia/Singapore"));    // UTC+8
        offices.put("纽约分部", ZoneId.of("America/New_York"));    // UTC-5 / -4(夏令时)
        offices.put("伦敦分部", ZoneId.of("Europe/London"));       // UTC+0 / +1(夏令时)
        offices.put("柏林研发中心", ZoneId.of("Europe/Berlin"));   // UTC+1 / +2(夏令时)
        offices.put("悉尼分部", ZoneId.of("Australia/Sydney"));    // UTC+10 / +11(夏令时)

        // ===== 1. 北京总部当前时间 =====
        ZonedDateTime beijingTime = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z (O)");

        System.out.println("【北京总部时间】");
        System.out.println("  " + beijingTime.format(fmt));
        System.out.println("  UTC偏移: " + beijingTime.getOffset());
        System.out.println("  时区: " + beijingTime.getZone());
        System.out.println();

        // ===== 2. 全部办公室当前时间 =====
        System.out.println("【全球各办公室当前时间（基于同一 UTC 瞬时点）】");
        Instant now = Instant.now(); // UTC 基准
        System.out.printf("  %-16s %-30s %s\n", "地点", "本地时间", "UTC偏移");
        System.out.println("  " + "-".repeat(65));

        for (Map.Entry<String, ZoneId> entry : offices.entrySet()) {
            ZonedDateTime localTime = now.atZone(entry.getValue());
            System.out.printf("  %-16s %-30s %s\n",
                entry.getKey(),
                localTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")),
                localTime.getOffset());
        }

        // ===== 3. 时差计算 =====
        System.out.println("\n【时差计算】");
        ZoneId beijing = ZoneId.of("Asia/Shanghai");
        ZoneId newYork = ZoneId.of("America/New_York");
        ZoneId london = ZoneId.of("Europe/London");

        ZonedDateTime bjNow = ZonedDateTime.now(beijing);
        ZonedDateTime nyNow = bjNow.withZoneSameInstant(newYork); // 同一时刻
        ZonedDateTime londonNow = bjNow.withZoneSameInstant(london);

        System.out.printf("  当北京是 %s\n",
            bjNow.format(DateTimeFormatter.ofPattern("HH:mm")));
        System.out.printf("  纽约是 %s (%s 天)\n",
            nyNow.format(DateTimeFormatter.ofPattern("HH:mm")),
            nyNow.toLocalDate().equals(bjNow.toLocalDate()) ? "同" :
                (nyNow.toLocalDate().isBefore(bjNow.toLocalDate()) ? "前" : "后"));
        System.out.printf("  伦敦是 %s (%s 天)\n",
            londonNow.format(DateTimeFormatter.ofPattern("HH:mm")),
            londonNow.toLocalDate().equals(bjNow.toLocalDate()) ? "同" :
                (londonNow.toLocalDate().isBefore(bjNow.toLocalDate()) ? "前" : "后"));

        // ===== 4. 会议时间选择 =====
        System.out.println("\n【全球会议时间推荐】");

        // 假设选在北京时间 20:00 开会
        LocalTime meetingBeijingTime = LocalTime.of(20, 0); // 晚上8点
        ZonedDateTime meetingBeijing = ZonedDateTime.of(
                LocalDate.now(), meetingBeijingTime, beijing);

        System.out.println("  提议会议时间（北京时间）: " +
                meetingBeijing.format(DateTimeFormatter.ofPattern("HH:mm")));
        System.out.println();

        // 检查各办公室是否在工作时间（9:00-18:00）
        System.out.printf("  %-16s %-12s %-15s\n", "办公室", "本地时间", "是否工作时间");
        System.out.println("  " + "-".repeat(50));

        for (Map.Entry<String, ZoneId> entry : offices.entrySet()) {
            ZonedDateTime localMeeting = meetingBeijing.withZoneSameInstant(entry.getValue());
            LocalTime localTime = localMeeting.toLocalTime();
            boolean isWorkingHour = !localTime.isBefore(LocalTime.of(9, 0))
                    && !localTime.isAfter(LocalTime.of(18, 0));

            System.out.printf("  %-16s %-12s %-15s\n",
                entry.getKey(),
                localTime.format(DateTimeFormatter.ofPattern("HH:mm")),
                isWorkingHour ? "✓ 工作时间" : "✗ 非工作时间");
        }

        // ===== 5. 夏令时影响演示 =====
        System.out.println("\n【夏令时影响】");
        // 纽约 2024年3月10日进入夏令时（UTC-4），11月3日退出（UTC-5）
        LocalDate beforeDST = LocalDate.of(2024, 3, 9);
        LocalDate afterDST = LocalDate.of(2024, 3, 11);

        ZonedDateTime nyBeforeDST = ZonedDateTime.of(beforeDST,
                LocalTime.of(12, 0), newYork);
        ZonedDateTime nyAfterDST = ZonedDateTime.of(afterDST,
                LocalTime.of(12, 0), newYork);

        System.out.println("  纽约 2024年3月9日 12:00 偏移: " + nyBeforeDST.getOffset());  // -05:00
        System.out.println("  纽约 2024年3月11日 12:00 偏移: " + nyAfterDST.getOffset()); // -04:00
        System.out.println("  说明：3月10日凌晨进入夏令时，时钟拨快1小时");

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

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.*;
import java.util.*;

/**
 * 飞翔科技项目管理系统 —— 里程碑日期计算
 * 演示 Period、TemporalAdjusters、自定义 TemporalAdjuster
 */
public class FeixiangProjectMilestoneDemo {

    // 自定义 TemporalAdjuster：找最近的工作日（跳过周末）
    static class NextWorkingDay implements TemporalAdjuster {
        @Override
        public Temporal adjustInto(Temporal temporal) {
            DayOfWeek dow = DayOfWeek.from(temporal);
            int daysToAdd = 1;
            if (dow == DayOfWeek.FRIDAY) {
                daysToAdd = 3;  // 周五 → 下周一
            } else if (dow == DayOfWeek.SATURDAY) {
                daysToAdd = 2;  // 周六 → 下周一
            }
            return temporal.plus(daysToAdd, ChronoUnit.DAYS);
        }
    }

    // 自定义 TemporalAdjuster：找本季度第一天
    static class FirstDayOfQuarter implements TemporalAdjuster {
        @Override
        public Temporal adjustInto(Temporal temporal) {
            LocalDate date = LocalDate.from(temporal);
            int month = date.getMonthValue();
            int quarterStartMonth = ((month - 1) / 3) * 3 + 1;
            return date.withMonth(quarterStartMonth).withDayOfMonth(1);
        }
    }

    public static void main(String[] args) {
        System.out.println("========== 飞翔科技项目里程碑系统 ==========\n");

        DateTimeFormatter dateFmt = DateTimeFormatter.ofPattern("yyyy年MM月dd日 (EEEE)");

        // ===== 1. 项目基本信息 =====
        LocalDate projectStart = LocalDate.of(2024, 3, 15);
        System.out.println("【项目启动日期】" + projectStart.format(dateFmt));
        System.out.println();

        // ===== 2. 使用 Period 计算阶段间隔 =====
        System.out.println("【里程碑计划（使用 plus/Period）】");
        System.out.println("-".repeat(45));

        // 需求分析阶段：2周
        LocalDate requirementEnd = projectStart.plusWeeks(2);
        Period reqPeriod = Period.between(projectStart, requirementEnd);
        System.out.printf("  需求分析: %s → %s (%d 天)\n",
            projectStart.format(dateFmt),
            requirementEnd.format(dateFmt),
            reqPeriod.getDays());

        // 设计阶段：3周
        LocalDate designEnd = requirementEnd.plusWeeks(3);
        Period designPeriod = Period.between(requirementEnd, designEnd);
        System.out.printf("  系统设计: %s → %s (%d 周)\n",
            requirementEnd.format(dateFmt),
            designEnd.format(dateFmt),
            designPeriod.getDays() / 7);

        // 开发阶段：8周
        LocalDate devEnd = designEnd.plusWeeks(8);
        System.out.printf("  开发编码: %s → %s (8 周)\n",
            designEnd.format(dateFmt),
            devEnd.format(dateFmt));

        // 测试阶段：4周
        LocalDate testEnd = devEnd.plusWeeks(4);
        System.out.printf("  测试阶段: %s → %s (4 周)\n",
            devEnd.format(dateFmt),
            testEnd.format(dateFmt));

        // 部署上线：1周
        LocalDate deployEnd = testEnd.plusWeeks(1);
        System.out.printf("  部署上线: %s → %s (1 周)\n",
            testEnd.format(dateFmt),
            deployEnd.format(dateFmt));

        // 总工期
        Period totalPeriod = Period.between(projectStart, deployEnd);
        System.out.printf("\n  总工期: %d 个月 %d 天 (共 %d 天)\n",
            totalPeriod.getMonths(),
            totalPeriod.getDays(),
            ChronoUnit.DAYS.between(projectStart, deployEnd));

        // ===== 3. TemporalAdjusters 使用 =====
        System.out.println("\n【使用 TemporalAdjusters 计算关键日期】");
        System.out.println("-".repeat(45));

        // 找到上线日期所在月的最后一天
        LocalDate lastDayOfMonth = deployEnd.with(TemporalAdjusters.lastDayOfMonth());
        System.out.printf("  部署所在月最后一天: %s\n", lastDayOfMonth.format(dateFmt));

        // 找到测试阶段开始的第一个周一
        LocalDate firstMonday = devEnd.with(TemporalAdjusters.nextOrSame(DayOfWeek.MONDAY));
        System.out.printf("  开发结束后第一个周一: %s\n", firstMonday.format(dateFmt));

        // 下个季度第一天
        LocalDate nextQuarter = deployEnd.with(new FirstDayOfQuarter());
        System.out.printf("  部署所在季度第一天: %s\n",
            deployEnd.with(new FirstDayOfQuarter()).plusMonths(3).format(dateFmt));

        // 本月第二个周五（版本发布日期候选）
        LocalDate secondFriday = deployEnd.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.FRIDAY));
        System.out.printf("  本月第二个周五（候选发布日期）: %s\n",
            secondFriday.format(dateFmt));

        // ===== 4. Duration 用时计算 =====
        System.out.println("\n【工作时长计算（Duration）】");

        // 大翔今天的工作时间
        LocalTime workStart = LocalTime.of(9, 0);
        LocalTime lunchStart = LocalTime.of(12, 0);
        LocalTime lunchEnd = LocalTime.of(13, 30);
        LocalTime workEnd = LocalTime.of(18, 30);

        Duration morningDuration = Duration.between(workStart, lunchStart);
        Duration afternoonDuration = Duration.between(lunchEnd, workEnd);
        Duration totalWorkDuration = morningDuration.plus(afternoonDuration);

        System.out.printf("  上午工作时间: %s ~ %s = %d 小时\n",
            workStart, lunchStart, morningDuration.toHours());
        System.out.printf("  午休时间:     %s ~ %s = %d 分钟\n",
            lunchStart, lunchEnd, Duration.between(lunchStart, lunchEnd).toMinutes());
        System.out.printf("  下午工作时间: %s ~ %s = %d 小时\n",
            lunchEnd, workEnd, afternoonDuration.toHours());
        System.out.printf("  全天工作时长: %d 小时 %d 分钟\n",
            totalWorkDuration.toHours(),
            totalWorkDuration.toMinutesPart());  // JDK 9+ 才有 toMinutesPart()
        // JDK 8 替代：
        long totalMinutes = totalWorkDuration.toMinutes();
        System.out.printf("  全天工作时长: %d 小时 %d 分钟 (JDK8方式)\n",
            totalMinutes / 60, totalMinutes % 60);

        // ===== 5. 自定义 TemporalAdjuster：跳转到下一个工作日 =====
        System.out.println("\n【自定义 TemporalAdjuster：工作日计算】");

        // 假设测试结束日是周六，部署应该从下周一算起
        LocalDate testEndFriday = LocalDate.of(2024, 9, 13); // 周五
        LocalDate nextWorkingDay = testEndFriday.with(new NextWorkingDay());
        System.out.printf("  测试结束于周五 %s\n", testEndFriday.format(dateFmt));
        System.out.printf("  下一个工作日: %s\n", nextWorkingDay.format(dateFmt));

        LocalDate testEndSaturday = LocalDate.of(2024, 9, 14); // 周六
        LocalDate nextWorkingDay2 = testEndSaturday.with(new NextWorkingDay());
        System.out.printf("  若结束于周六 %s\n", testEndSaturday.format(dateFmt));
        System.out.printf("  下一个工作日: %s\n", nextWorkingDay2.format(dateFmt));

        // ===== 6. 版本发布时间 =====
        System.out.println("\n【版本发布时间线】");
        System.out.println("-".repeat(45));
        String[] versions = {"v1.0 Alpha", "v1.0 Beta", "v1.0 RC", "v1.0 GA"};
        LocalDate baseDate = LocalDate.of(2024, 3, 15);

        for (int i = 0; i < versions.length; i++) {
            LocalDate releaseDate = baseDate.plusMonths(i * 2);
            // 总是发布在周五（或最近的工作日）
            LocalDate adjustedDate = releaseDate.with(TemporalAdjusters.nextOrSame(DayOfWeek.FRIDAY));
            System.out.printf("  %-12s 计划发布: %s\n",
                versions[i], adjustedDate.format(dateFmt));
        }

        // ===== 7. 不可变性证明 =====
        System.out.println("\n【不可变性证明】");
        LocalDate original = LocalDate.of(2024, 3, 15);
        LocalDate modified = original.plusDays(10);
        System.out.println("  original.plusDays(10):");
        System.out.println("    original = " + original); // 2024-03-15（不变！）
        System.out.println("    modified = " + modified); // 2024-03-25（新对象）

        System.out.println("\n========== 项目计划生成完毕 ==========");
    }
}

// ✗ 错误：LocalDateTime 不含时区，跨时区系统会出问题
LocalDateTime now = LocalDateTime.now(); // 取决于服务器时区
// 如果服务器从北京迁移到纽约，now 的含义完全不同！

// ✓ 正确：使用 Instant 存时间戳
Instant now = Instant.now(); // UTC 时间，全球唯一

// ✓ 或者：存带时区的时间
ZonedDateTime now = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));
// 明确表达了"北京时间"

// 黄金法则：时间戳用 Instant，人类可读时间用 ZonedDateTime

// ✗ 错误理解
LocalDateTime start = LocalDateTime.of(2024, 3, 15, 9, 0);
LocalDateTime end = LocalDateTime.of(2024, 3, 15, 18, 0);
Period period = Period.between(start.toLocalDate(), end.toLocalDate());
System.out.println(period.getDays()); // 输出: 0  ← 跨天才会计数！

// ✓ 正确：时间差用 Duration
Duration duration = Duration.between(start, end);
System.out.println(duration.toHours()); // 输出: 9

// ✗ 旧代码：SimpleDateFormat 线程不安全
private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd");
// 多线程同时调用 SDF.parse() → 数据错乱或 NumberFormatException

// ✓ 新代码：DateTimeFormatter 线程安全
private static final DateTimeFormatter DTF =
        DateTimeFormatter.ofPattern("yyyy-MM-dd");
// 多线程安全使用！

// ✗ 旧习惯：Date 月份从 0 开始，+1 是标准操作
// int month = new Date().getMonth() + 1;  // 需要 +1

// ✓ java.time：月份自然表达
int month = LocalDate.now().getMonthValue();     // 3 就是 3 月
Month monthEnum = LocalDate.now().getMonth();    // Month.MARCH
// 不需要任何加减操作！

Period.between(LocalDate.of(2024,1,1), LocalDate.of(2024,3,15))  // P2M14D
Duration.between(LocalTime.of(9,0), LocalTime.of(17,30))          // PT8H30M