深入了解Java8新特性-日期时间API：LocalTime类

news/2024/5/19 11:57:52 标签: java, java8新特性, 日期时间API, LocalTime

阅读建议

嗨，伙计！刷到这篇文章咱们就是有缘人，在阅读这篇文章前我有一些建议：

  1. 本篇文章大概12000多字，预计阅读时间长需要10分钟。
  2. 本篇文章的实战性、理论性较强，是一篇质量分数较高的技术干货文章，建议收藏起来，方便时常学习与回顾，温故而知新。
  3. 创作不易，免费的点赞、关注，请走上一走，算是对博主一些鼓励，让我更有动力输出更多的干货内容。

前言

        Java 8引入了一个非常重要的，用于处理时间的类：LocalTime。LocalTime可以表示一天中的时间，不包括日期信息。它提供了各种方法来处理时间，例如获取当前时间、设置时间、获取小时、分钟、秒等。

LocalTime的核心方法

jdk版本

jdk11

LocalTime#now

        LocalTime.now() 是用于获取当前本地时间的函数。它属于 java.time.LocalTime 类。这个方法不需要任何参数，当调用时，它会返回一个 LocalTime 对象，该对象表示当前的本地时间。

java">@Test
public void test() {
    LocalTime localTime = LocalTime.now();
    System.out.println(localTime);
}

LocalTime#of

        在Java 11中，LocalTime.of()方法用于创建一个表示本地时间的LocalTime对象。这个方法接受一组时、分、秒和纳秒参数，并返回一个表示该时间的LocalTime对象。

        参数说明：

  • hour：表示小时的整数，范围从0到23。
  • minute：表示分钟的整数，范围从0到59。
  • second：表示秒的整数，范围从0到59。
  • nanoOfSecond：表示纳秒的整数，范围从0到999999999。
java">@Test
public void test2() {
    LocalTime localTime = LocalTime.of(10, 20);
    System.out.println(localTime);//输出结果：10:20
    LocalTime localTime1 = LocalTime.of(11, 12, 59);
    System.out.println(localTime1);//输出结果：11:12:59
    LocalTime localTime2 = LocalTime.of(13, 12, 59, 59);
    System.out.println(localTime2);//输出结果：13:12:59.000000059
}

LocalTime#ofInstant、LocalTime#ofSecondOfDay、LocalTime#ofNanoOfDay

        LocalTime 类提供了几个静态方法来创建 LocalTime 实例，其中包括 ofInstant(), ofSecondOfDay(), 和 ofNanoOfDay()。这些方法的功能和作用如下：

  • LocalTime#ofInstant(Instant instant, ZoneId zone)：此方法接受一个 Instant 对象和一个 ZoneId 对象作为参数，并返回一个表示该瞬间的本地时间。Instant 是时间戳的一种表示形式，它表示自1970年1月1日00:00:00 UTC以来的秒数和纳秒数。ZoneId 是一个时区标识符，用于确定特定的时区。
  • LocalTime#ofSecondOfDay(long secondOfDay)：此方法接受一个长整型数值作为参数，该值表示从当天的开始到指定时间的秒数。这个方法的目的是创建表示特定秒数的一天中的时间。
  • LocalTime#ofNanoOfDay(long nanoOfDay)：此方法接受一个长整型数值作为参数，该值表示从当天的开始到指定时间的纳秒数。这个方法的目的是创建表示特定纳秒数的一天中的时间。

        这三个方法提供了一种灵活的方式来创建 LocalTime 实例，可以根据你的需求选择使用哪种方式。

java">@Test
public void test3() {
    LocalTime localTime = LocalTime.ofInstant(Instant.now(), ZoneId.systemDefault());
    System.out.println(localTime);
    LocalTime localTime1 = LocalTime.ofNanoOfDay(1000000000L);
    System.out.println(localTime1);//00:00:01
    LocalTime localTime2 = LocalTime.ofSecondOfDay(10L);
    System.out.println(localTime2);//输出结果：00:00:10
}

LocalTime#from

        LocalTime.from() 方法用于从给定的时间戳（long）或Instant对象创建一个LocalTime实例。需要注意的是，这些方法在创建LocalTime实例时，将忽略时区信息。LocalTime表示的是没有时区的本地时间。如果你需要具有时区的准确时间，请考虑使用ZonedDateTime类。

java">@Test
public void test4() {
    LocalDateTime localDateTime = LocalDateTime.of(2023, 12, 11, 18, 59, 59);
    LocalTime from = LocalTime.from(localDateTime);
    System.out.println(from);//输出结果：18:59:59
}

LocalTime#parse

        LocalTime.parse()方法是用于将字符串解析为LocalTime对象的方法。该方法接受一个字符串作为参数，并尝试将其解析为时间，返回一个表示该时间的LocalTime对象。使用LocalTime.parse()方法时，需要确保传递给该方法的字符串符合24小时制的时间格式，即小时、分钟和秒的顺序。如果字符串的格式不符合要求，将会抛出DateTimeParseException异常。

java">@Test
public void test5() {
    LocalTime parse = LocalTime.parse("23:59:59");
    LocalTime parse1 = LocalTime.parse("21:58:59", DateTimeFormatter.ISO_TIME);
    System.out.println(parse);
    System.out.println(parse1);
}

LocalTime#isSupported

        LocalTime#isSupported()用于检查LocalTime类是否支持指定的字段。这意味着，通过使用此方法，我们可以检查是否可以针对指定的字段进行此LocalTime的查询。如果LocalTime类支持某个字段，那么就可以使用这个字段进行时间的查询和操作。如果LocalTime类不支持某个字段，那么调用与该字段相关的查询和操作方法将会抛出异常。

java">@Test
public void test6() {
    LocalTime now = LocalTime.now();
    boolean supported = now.isSupported(ChronoUnit.HOURS);
    boolean supported1 = now.isSupported(ChronoUnit.YEARS);
    System.out.println(supported);
    System.out.println(supported1);
}

LocalTime#range

        LocalTime类的range()用于返回一个表示时间范围内的LocalTime对象范围。该方法接受一个LocalTime对象作为参数，并返回一个包含该时间点之前和之后时间的范围。

java">@Test
public void test7() {
    LocalTime now = LocalTime.now();
    ValueRange range = now.range(ChronoField.HOUR_OF_DAY);
    System.out.println(range.getMaximum());//输出结果：23
    System.out.println(range.getMinimum());//输出结果：0
    ValueRange range1 = now.range(ChronoField.MINUTE_OF_HOUR);
    System.out.println(range1.getMaximum());//输出结果：59
    System.out.println(range1.getMinimum());//输出结果：0
}

LocalTime#get、LocalTime#getLong、LocalTime#getHour、LocalTime#getMinute、LocalTime#getSecond

        LocalTime类中的get、getLong、getHour、getMinute和getSecond方法用于获取LocalTime对象中的时间部分。

  • get(TemporalField field)方法：该方法用于获取LocalTime对象中指定的时间字段。TemporalField是一个接口，它定义了时间的各种字段，如小时、分钟、秒等。
  • getLong(TemporalField field)方法：这个方法与get方法类似，但返回的是长整型值，而不是整型值。
  • getHour()方法：该方法用于获取LocalTime对象中的小时数。
  • getMinute()方法：该方法用于获取LocalTime对象中的分钟数。
  • getSecond()方法：该方法用于获取LocalTime对象中的秒数。
java">@Test
public void test8() {
    LocalTime localTime = LocalTime.of(15, 59, 59);
    int hour = localTime.get(ChronoField.HOUR_OF_DAY);
    int minute = localTime.get(ChronoField.MINUTE_OF_HOUR);
    int second = localTime.get(ChronoField.SECOND_OF_MINUTE);
    System.out.println(hour + "," + minute + "," + second);
    int hour1 = localTime.getHour();
    int minute1 = localTime.getMinute();
    int second1 = localTime.getSecond();
    System.out.println(hour1 + "," + minute1 + "," + second1);
}

LocalTime#with、LocalTime#withHour、LocalTime#withMinute、LocalTime#withSecond

        LocalTime类中的with、withHour、withMinute和withSecond方法用于修改和创建新的LocalTime实例，这些方法提供了一种方便的方式来创建和修改本地时间实例的各个字段。它们不会改变原始的LocalTime实例，而是返回一个新的实例。

  • LocalTime.with(TemporalField, long)：这个方法根据给定的时间字段和值，返回一个新的本地时间实例。这个方法可以用于修改小时、分钟、秒以及纳秒等字段。例如，LocalTime.now().with(ChronoField.HOUR_OF_DAY, 10)将返回一个新的本地时间，该时间的小时字段为10。
  • LocalTime.withHour(int hour)：这个方法返回一个新的本地时间实例，该实例的小时字段与给定的小时字段相匹配。例如，LocalTime.now().withHour(10)将返回一个新的本地时间，该时间的小时字段为10。
  • LocalTime.withMinute(int minute)：这个方法返回一个新的本地时间实例，该实例的分钟字段与给定的分钟字段相匹配。例如，LocalTime.now().withMinute(30)将返回一个新的本地时间，该时间的分钟字段为30。
  • LocalTime.withSecond(int second)：这个方法返回一个新的本地时间实例，该实例的秒字段与给定的秒字段相匹配。例如，LocalTime.now().withSecond(45)将返回一个新的本地时间，该时间的秒字段为45。
java">@Test
public void test9() {
    LocalTime localTime = LocalTime.of(15, 59, 59);
    TemporalAdjuster temporalAdjuster = item -> item.plus(1, ChronoUnit.HOURS);//调节器逻辑：加1小时
    LocalTime result = localTime.with(temporalAdjuster);//执行一个时间调节器的调节逻辑
    System.out.println(result);//输出结果：16:59:59
    LocalTime localTime1 = localTime.withHour(2);//指定hh::mm的hh部分为2
    System.out.println(localTime1);//输出结果：02:59:59
    LocalTime localTime2 = localTime.withMinute(2);//指定hh::mm的mm部分为2
    System.out.println(localTime2);//输出结果：15:02:59
    LocalTime localTime3 = localTime.withSecond(1);
    System.out.println(localTime3);//输出结果：15:59:01
}

LocalTime#truncatedTo

        LocalTime.truncatedTo()方法用于将当前时间截断到指定的时间单位。它接受一个DurationUnit参数，该参数表示要截断的时间单位，例如分钟、小时、天等。需要注意的是，截断操作不会改变原始的LocalTime实例，而是返回一个新的实例。

java">@Test
public void test10() {
    LocalTime localTime = LocalTime.of(10, 31, 59, 1);
    LocalTime localTime1 = localTime.truncatedTo(ChronoUnit.HOURS);
    LocalTime localTime2 = localTime.truncatedTo(ChronoUnit.MINUTES);
    LocalTime localTime3 = localTime.truncatedTo(ChronoUnit.SECONDS);
    System.out.println(localTime1);//输出结果：10:00
    System.out.println(localTime2);//输出结果：10:31
    System.out.println(localTime3);//输出结果：10:31:59
}

LocalTime#plus、LocalTime#plusHours、LocalTime#plusMinutes、LocalTime#plusSeconds

        LocalTime类中的plus、plusHours、plusMinutes和plusSeconds方法用于在现有的LocalTime实例上添加指定的时间量，它们返回一个新的本地时间实例，而不是修改原始的实例。

  • LocalTime.plus(Duration amountToAdd)：这个方法接受一个Duration对象作为参数，该对象表示要添加的时间量。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的时间量。例如，LocalTime.now().plus(Duration.ofHours(2))将在现有的本地时间上添加两个小时，并返回一个新的本地时间实例。
  • LocalTime.plusHours(long hoursToAdd)：这个方法接受一个长整型数值作为参数，表示要添加的小时数。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的小时数。例如，LocalTime.now().plusHours(2)将在现有的本地时间上添加两个小时，并返回一个新的本地时间实例。
  • LocalTime.plusMinutes(long minutesToAdd)：这个方法接受一个长整型数值作为参数，表示要添加的分钟数。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的分钟数。例如，LocalTime.now().plusMinutes(30)将在现有的本地时间上添加30分钟，并返回一个新的本地时间实例。
  • LocalTime.plusSeconds(long secondsToAdd)：这个方法接受一个长整型数值作为参数，表示要添加的秒数。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的秒数。例如，LocalTime.now().plusSeconds(45)将在现有的本地时间上添加45秒，并返回一个新的本地时间实例。
java">@Test
public void test11() {
    LocalTime localTime = LocalTime.of(10, 12, 19);
    LocalTime localTime1 = localTime.plus(1, ChronoUnit.HOURS);
    System.out.println(localTime1);//输出结果：11:12:19
    LocalTime localTime4 = localTime.plusHours(1);
    System.out.println(localTime.equals(localTime4));//输出结果：true
    LocalTime localTime2 = localTime.plus(1, ChronoUnit.MINUTES);
    System.out.println(localTime2);//输出结果：10:13:19
    LocalTime localTime5 = localTime.plusMinutes(1);
    System.out.println(localTime2.equals(localTime5));//输出结果为：true
    LocalTime localTime3 = localTime.plus(1, ChronoUnit.SECONDS);
    System.out.println(localTime3);//输出结果：10:12:20
    LocalTime localTime6 = localTime.plusSeconds(1);
    System.out.println(localTime3.equals(localTime6));//输出结果：true
}

LocalTime#minus、LocalTime#minusHours、LocalTime#minusMinutes、LocalTime#minusSeconds

        LocalTime类中的minus、minusHours、minusMinutes和minusSeconds方法用于从当前时间减去指定的时间量。它们不会改变原始的LocalTime实例，而是返回一个新的实例。

  • LocalTime.minus(long amountToSubtract, TemporalUnit unit)：此方法根据给定的时间量（以给定的时间单位为单位）从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minus(2, ChronoUnit.HOURS)将返回一个新的本地时间，该时间比当前时间早2小时。
  • LocalTime.minusHours(long hoursToSubtract)：此方法根据给定的小时数从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minusHours(2)将返回一个新的本地时间，该时间比当前时间早2小时。
  • LocalTime.minusMinutes(long minutesToSubtract)：此方法根据给定的分钟数从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minusMinutes(30)将返回一个新的本地时间，该时间比当前时间早30分钟。
  • LocalTime.minusSeconds(long secondsToSubtract)：此方法根据给定的秒数从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minusSeconds(45)将返回一个新的本地时间，该时间比当前时间早45秒。
java">@Test
public void test12() {
    LocalTime localTime = LocalTime.of(20, 20, 30);
    LocalTime minus = localTime.minus(10, ChronoUnit.HOURS);
    System.out.println(minus);//输出结果：10:20:30
    LocalTime localTime1 = localTime.minusHours(10);
    System.out.println(localTime1.equals(minus));//输出结果：true
    LocalTime minus1 = localTime.minus(10, ChronoUnit.MINUTES);
    System.out.println(minus1);//输出结果：20:10:30
    LocalTime localTime2 = localTime.minusMinutes(10);
    System.out.println(localTime2.equals(minus1));//输出结果：true
    LocalTime minus2 = localTime.minus(10, ChronoUnit.SECONDS);
    System.out.println(minus2);//输出结果：20:20:20
    LocalTime localTime3 = localTime.minusSeconds(10);
    System.out.println(localTime3.equals(minus2));//输出结果：true
}

LocalTime#query

        LocalTime类中的query方法用于对时间进行查询和获取相关信息。它接受一个 TemporalQuery参数，该参数定义了要查询的时间属性和返回的数据类型。

java">@Test
public void test13(){
    LocalTime localTime=LocalTime.of(20,20,20);
    TemporalQuery<Integer> temporalQuery=item->item.get(ChronoField.HOUR_OF_DAY);
    Integer query = localTime.query(temporalQuery);
    System.out.println(query);//输出结果：20
}

LocalTime#until

        LocalTime.until() 方法用于计算两个时间点之间的时间差。可以计算精确的时间差，包括天数、小时数、分钟数和秒数。它考虑了时间的小数部分，因此可以提供精确到秒的时间差。

java">@Test
public void test14(){
    LocalTime now = LocalTime.of(20,19);
    long until = now.until(LocalTime.of(23, 19), ChronoUnit.HOURS);
    System.out.println(until);//输出结果：3
}

LocalTime#format

        LocalTime类的format()方法用于将当前时间转换为指定的时间格式。该方法接受一个DateTimeFormatter对象作为参数，用于指定时间格式。DateTimeFormatter是Java 8引入的一个时间日期格式化工具，它提供了一种灵活的方式来指定日期和时间的格式。通过使用DateTimeFormatter，您可以定义所需的时间格式，例如使用特定的时间符号、日期格式和时区等。

java">@Test
public void test15(){
    LocalTime now = LocalTime.now();
    String format = now.format(DateTimeFormatter.ISO_TIME);
    System.out.println(format);//输出结果：11:59:12.4188079
}

LocalTime#atDate

        LocalTime类中的atDate()方法用于将LocalTime与日期（年、月、日）结合在一起，生成一个新的LocalDateTime对象。它接受一个LocalDate对象作为参数，并返回一个表示特定日期和时间的LocalDateTime对象。这个方法可以用于在给定日期的基础上添加时间信息，或者将时间与日期结合起来创建更完整的日期时间对象。通过将LocalTime与LocalDate结合使用，可以方便地创建包含日期和时间信息的对象，以便进行日程安排、计划等操作。

java">@Test
public void test16(){
    LocalTime localTime = LocalTime.of(20, 30, 59);
    LocalDate localDate=LocalDate.of(2023,11,21);
    LocalDateTime localDateTime = localTime.atDate(localDate);
    System.out.println(localDateTime);//输出结果：2023-11-21T20:30:59

}

LocalTime#atOffset

        LocalTime.atOffset()方法的功能是返回一个表示给定时间偏移量的OffsetTime对象，可以用于表示比本地时间更早或更晚的时间。通过将偏移量应用到本地时间上，可以方便地获取一个在特定偏移量之后或之前的另一个时间。

java">@Test
public void test17(){
    LocalTime localTime = LocalTime.of(20, 30, 59);
    ZoneOffset zoneOffset=ZoneOffset.ofHours(8);
    OffsetTime offsetTime = localTime.atOffset(zoneOffset);
    System.out.println(offsetTime);//输出结果：20:30:59+08:00
}

LocalTime#toSecondOfDay

        LocalTime.toSecondOfDay()方法的功能是将当前LocalTime实例转换为从当天开始到该时间为止的秒数。

java">@Test
public void test18(){
    LocalTime localTime = LocalTime.of(1, 0, 0);
    int secondOfDay = localTime.toSecondOfDay();
    System.out.println(secondOfDay);//输出结果：3600
}

LocalTime#toNanoOfDay

        LocalTime.toNanoOfDay()通过将LocalTime对象中的时间成分（小时、分钟、秒和毫秒）转换为纳秒，可以获得一个表示该时间的纳秒级数值。这个数值表示的是从当天的午夜开始到该时间为止的总纳秒数。

java">@Test
public void test19(){
    LocalTime localTime = LocalTime.of(1, 0, 0);
    Long nanoOfDay = localTime.toNanoOfDay();
    System.out.println(nanoOfDay);//输出结果：3600000000000
}

LocalTime#compareTo、LocalTime#isAfter、LocalTime#isBefore

        LocalTime类中的compareTo()、isAfter()和isBefore()方法用于比较和处理时间。

  • compareTo()方法：该方法用于比较两个LocalTime对象。它基于时间的时间点进行比较，返回一个整数值，表示当前时间对象与指定时间对象的相对顺序。如果当前时间对象在指定时间对象之前，则返回负整数；如果当前时间对象在指定时间对象之后，则返回正整数；如果两者相等，则返回0。
  • isAfter()方法：该方法用于检查当前LocalTime对象是否在指定时间之后。它返回一个布尔值，如果当前时间对象在指定时间之后，则返回true；否则返回false。
  • isBefore()方法：该方法用于检查当前LocalTime对象是否在指定时间之前。它返回一个布尔值，如果当前时间对象在指定时间之前，则返回true；否则返回false。
java">@Test
public void  test20(){
    LocalTime localTime=LocalTime.of(1,0,0);
    LocalTime localTime1 = LocalTime.of(2, 30, 59);
    int i = localTime.compareTo(localTime1);
    System.out.println(i);//输出结果：-1
    boolean after = localTime.isAfter(localTime1);
    System.out.println(after);//输出结果：false
    boolean before = localTime.isBefore(localTime1);
    System.out.println(before);//输出结果：true
}

适用场景

LocalTime是Java 8引入的一个类，用于表示一天中的时间，不包括日期信息。它在以下场景中特别有用：

  • 时间计算和操作：LocalTime可以用于执行各种时间计算，如获取当前时间、增加或减少时间、计算两个时间的差等。
  • 日程安排和提醒：如果你需要设置一个特定的时间进行任务或活动，例如会议、约会或闹钟，LocalTime可以用来表示这个特定的时间。
  • 时间筛选：在处理大量数据时，可能需要基于时间进行筛选。例如，你可能需要找出在特定时间段内的所有交易记录。使用LocalTime可以很容易地定义和比较这些时间段。
  • 时间格式化：LocalTime提供了一些方法来格式化和解析时间字符串。你可以使用DateTimeFormatter来定义你需要的格式，然后使用LocalTime的format()和parse()方法来进行格式化和解析。
  • 时间展示和用户交互：如果需要在用户界面上显示或接收来自用户的时间输入，LocalTime可以用来表示这个时间。例如，你可能需要让用户选择一个特定的时间段来安排一个活动。
  • 与其它日期/时间类型的交互：虽然LocalTime不包含日期信息，但它可以很容易地与包含日期的其他类（如LocalDateTime）进行交互。你可以从LocalDateTime中获取LocalTime，反之亦然。
  • 时间戳操作：虽然LocalTime不直接提供时间戳功能，但你可以轻松地将其转换为Instant或ZonedDateTime，这两个类都提供了时间戳相关的功能。

        总的来说，LocalTime适用于那些只需要处理一天中的时间，而不需要处理日期的场景。


http://www.niftyadmin.cn/n/5216664.html

相关文章

CentOS7部署FTP服务器

CentOS7部署FTP服务器

首先准备一台centos7虚拟机&#xff0c;作为服务器IP地址必须是固定的。 vim /etc/sysconfig/network-scripts/ifcfg-ens33配置内容如下&#xff1a; TYPE"Ethernet" PROXY_METHOD"none" BROWSER_ONLY"no" BOOTPROTO"static" DEFROU…
阅读更多...
vue3+tsx的使用

vue3+tsx的使用

<template><div><xiaoman on-click"getItem" name"似懂非懂"></xiaoman></div> </template><script setup langts>import xiaoman from "./App"const getItem(item:any)>{console.log(item,it…
阅读更多...
MIT6.824-Raft笔记:Raft初探、副本间log时序

MIT6.824-Raft笔记:Raft初探、副本间log时序

从宏观角度说明raft在程序中的作用&#xff0c;和客户端的关系&#xff0c;以及多个副本之间的关系&#xff1b;从微观角度说明多个副本之间raft对日志处理的流程。 1. Raft 初探 宏观角度说明raft在程序中的作用&#xff0c;和客户端的关系&#xff0c;以及多个副本之间的关…
阅读更多...
Java多线程二-线程安全

Java多线程二-线程安全

1、线程安全问题 多个线程&#xff0c;同时操作同一个共享资源的时候&#xff0c;可能会出现业务安全问题。 2、实例&#xff1a;取钱的线程安全问题 2.1、场景 小明和小红是夫妻&#xff0c;他们有个共同账户&#xff0c;余额是十万元&#xff0c;如果两人同时取钱并且各自取…
阅读更多...
二次创作Z01语言

二次创作Z01语言

目录 一&#xff0c;字符集 二&#xff0c;编译分词 三&#xff0c;token含义 四&#xff0c;Z01翻译成C 五&#xff0c;执行翻译后的代码 六&#xff0c;打印Hello World! 一&#xff0c;字符集 假设有门语言叫Z01语言&#xff0c;代码中只有0和1这两种字符。 二&#…
阅读更多...
什么是客户自助服务？综合指南献上~

什么是客户自助服务？综合指南献上~

《哈佛商业评论》曾报道过&#xff0c;81%的消费者在找客服之前会自己先去找办法解决。 如今&#xff0c;客户希望得到更快的响应。他们不想排队去等信息。他们想要的只是一个更快、更可靠的自助服务解决方案。作为企业&#xff0c;应该注意到他们的期望。企业需要做的就是通过…
阅读更多...
[Matlab有限元分析] 2.杆单元有限元分析

[Matlab有限元分析] 2.杆单元有限元分析

1. 一维杆单元有限元分析程序 一维刚单元的局部坐标系&#xff08;单元坐标系&#xff09;与全局坐标系相同。 1.1 线性杆单元 如图所示是一个杆单元&#xff0c;由两个节点i和j&#xff0c;局部坐标系的X轴沿着杆的方向&#xff0c;由i节点指向j节点&#xff0c;每个节点有…
阅读更多...
【题解】洛谷P3443 [POI2006] LIS-The Postman 题解

【题解】洛谷P3443 [POI2006] LIS-The Postman 题解

P3443 题意分析Code 题意 原题链接 求一条以 1 1 1 为起点的欧拉回路&#xff0c;使得给定路口序列在路线及求出的欧拉回路序列中出现。 分析 首先&#xff0c;肯定是要存在欧拉路径的。而有向图中存在欧拉路径须满足以下条件&#xff1a;图去掉孤立点后联通和每个点的入度…
阅读更多...
最新文章

Copyright @ 2022~2023