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

news2024/11/25 12:30:25

阅读建议

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

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

前言

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

LocalTime的核心方法

jdk版本

jdk11

LocalTime#now

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

@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。
@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 实例，可以根据你的需求选择使用哪种方式。

@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类。

@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异常。

@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类不支持某个字段，那么调用与该字段相关的查询和操作方法将会抛出异常。

@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对象作为参数，并返回一个包含该时间点之前和之后时间的范围。

@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对象中的秒数。
@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。
@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实例，而是返回一个新的实例。

@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秒，并返回一个新的本地时间实例。
@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秒。
@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参数，该参数定义了要查询的时间属性和返回的数据类型。

@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() 方法用于计算两个时间点之间的时间差。可以计算精确的时间差，包括天数、小时数、分钟数和秒数。它考虑了时间的小数部分，因此可以提供精确到秒的时间差。

@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，您可以定义所需的时间格式，例如使用特定的时间符号、日期格式和时区等。

@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结合使用，可以方便地创建包含日期和时间信息的对象，以便进行日程安排、计划等操作。

@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对象，可以用于表示比本地时间更早或更晚的时间。通过将偏移量应用到本地时间上，可以方便地获取一个在特定偏移量之后或之前的另一个时间。

@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实例转换为从当天开始到该时间为止的秒数。

@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对象中的时间成分（小时、分钟、秒和毫秒）转换为纳秒，可以获得一个表示该时间的纳秒级数值。这个数值表示的是从当天的午夜开始到该时间为止的总纳秒数。

@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。
@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.coloradmin.cn/o/1255500.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

人力资源管理后台 === 员工新增修改

人力资源管理后台 === 员工新增修改

目录 1.员工管理-导出excel 2.员工管理-excel组件封装 3.员工管理-下载导入模板 4.员工管理-员工导入-上传excel 5.员工管理-删除员工 6.员工详情和路由 7.员工详情-表单数据校验 8.员工详情-封装部门级联组件 9.员工详情-级联组件-双向绑定 10.员工详情-新增员工 11…
阅读更多...
深度学习中的注意力机制：原理、应用与实践

深度学习中的注意力机制：原理、应用与实践

深度学习中的注意力机制&#xff1a;原理、应用与实践 摘要&#xff1a; 本文将深入探讨深度学习中的注意力机制&#xff0c;包括其原理、应用领域和实践方法。我们将通过详细的解析和代码示例&#xff0c;帮助读者更好地理解和应用注意力机制&#xff0c;从而提升深度学习模…
阅读更多...
Servlet知识汇总

Servlet知识汇总

小王学习录 Ⅰ. servlet程序导入依赖创建目录编写代码打包程序部署程序验证简化打包和部署Ⅱ. Servlet Api1. HttpServlet2. HttpServletRequest3. HttpServletResponseⅢ. Cookie 和session1. Cookie2. Session(会话)3. session 和 cookie的区别4. session 和 cookie的联系5. …
阅读更多...
图像分割模型及架构选型介绍(MMSegmentation|sssegmentation等)

图像分割模型及架构选型介绍(MMSegmentation|sssegmentation等)

参考&#xff1a; https://zhuanlan.zhihu.com/p/618226513 0. 图像分割概述 图像分割通过给出图像中每个像素点的标签&#xff0c;将图像分割成若干带类别标签的区块&#xff0c;可以看作对每个像素进行分类。图像分割是图像处理的重要组成部分&#xff0c;也是难点之一。随…
阅读更多...
Java 基于 SpringBoot+Vue 的地方民宿管理系统

Java 基于 SpringBoot+Vue 的地方民宿管理系统

文章目录 开发环境&#xff1a;后端&#xff1a;前端&#xff1a;数据库&#xff1a; 系统架构&#xff1a;管理员&#xff1a;用户用例&#xff1a; 主要功能&#xff1a;用户功能模块管理员功能模块商家用户功能模块前台首页功能模块 源码咨询 大家好&#xff0c;今天为大家带…
阅读更多...
如何保证线程安全？

如何保证线程安全？

程序员的公众号&#xff1a;源1024&#xff0c;获取更多资料&#xff0c;无加密无套路&#xff01; 最近整理了一波电子书籍资料&#xff0c;包含《Effective Java中文版 第2版》《深入JAVA虚拟机》&#xff0c;《重构改善既有代码设计》&#xff0c;《MySQL高性能-第3版》&…
阅读更多...
Pytorch项目的文件结构一般都是怎么组织的？

Pytorch项目的文件结构一般都是怎么组织的？

如果是从一些比较典型的论文里弄下来的源码&#xff0c;你会发现它们的论文结构往往都非常复杂。不同的模型、不同的论文&#xff0c;可能代码结构组织的方式都不一样。但它们都不外乎就是经历这几个方面&#xff1a; 1、模型和结构模块定义&#xff1b; 2、数据集获取与处理…
阅读更多...
【brpc学习实践九】mbvar及bvar可观测

【brpc学习实践九】mbvar及bvar可观测

概念、学习地址 mbvar中有两个类&#xff0c;分别是MVariable和MultiDimension&#xff0c;MVariable是多维度统计的基类&#xff0c;MultiDimension是派生模板类。也是主要用来多多线程计数用的。这里用到再详细去了解即可 https://github.com/luozesong/brpc/blob/master/do…
阅读更多...
5.golang字符串的拆解和拼接

5.golang字符串的拆解和拼接

字符串是 Go 中的字节切片。可以通过将一组字符括在双引号中来创建字符串" "。Go 中的字符串是兼容Unicode编码的&#xff0c;并且是UTF-8编码的。 访问字符串的单个字节或字符 由于字符串是字节切片&#xff0c;因此可以访问字符串的每个字节。 func printStr(s …
阅读更多...
知识的分层：know-what/how/why

知识的分层：know-what/how/why

知识&#xff08;knowledge&#xff09;表示知道某些信息。通常而言&#xff0c;知识是正确的&#xff0c;但不一定是完备的。知识本身有自己的适用范围&#xff0c;特别是工程技术类问题。 根据知识的类型&#xff0c;可分为三类&#xff1a; know-whatknow-howknow-why kno…
阅读更多...
Redis 面试题——持久化

Redis 面试题——持久化

目录 1.概述1.1.Redis 的持久化功能是指什么&#xff1f;1.2.Redis 有哪些持久化机制&#xff1f; 2.RDB2.1.什么是 RDB 持久化&#xff1f;2.2.Redis 中使用什么命令来生成 RDB 快照文件&#xff1f;2.3.如何在 Redis 的配置文件中对 RDB 进行配置&#xff1f;2.4.✨RDB 持久化…
阅读更多...
代码随想录算法训练营 ---第四十四天

代码随想录算法训练营 ---第四十四天

今天开始《动态规划&#xff1a;完全背包》的学习&#xff01; 前言&#xff1a; 完全背包和01背包的区别在于完全背包里的物品能无限次使用&#xff0c;01背包只能用一次。 第一题&#xff1a; 简介&#xff1a; 本题是纯完全背包的使用。可以看一看和01背包的区别。 代码…
阅读更多...
手把手教你实现一个循环队列（C语言）

手把手教你实现一个循环队列（C语言）

这是一道leetcode关于队列的经典题&#xff1a; 622. 设计循环队列https://leetcode.cn/problems/design-circular-queue/ 思路&#xff1a; 大家注意这个题目要求&#xff0c;这个队列是定长的&#xff0c;如果满了则不能再添加数据。那么我们设计一个队头front和队尾rear&…
阅读更多...
单片机学习4——中断的概念

单片机学习4——中断的概念

中断的概念&#xff1a; CPU在处理A事件的时候&#xff0c;发生了B事件&#xff0c;请求CPU迅速去处理。&#xff08;中断产生&#xff09; CPU暂时中断当前的工作&#xff0c;转去处理B事件。&#xff08;中断响应和中断服务&#xff09; 待CPU将B事件处理完毕后&#xff0…
阅读更多...
Java王者荣耀小游戏

Java王者荣耀小游戏

Background类 package LX;import java.awt.*; //背景类 public class Background extends GameObject{public Background(GameFrame gameFrame) {super(gameFrame);}Image bg Toolkit.getDefaultToolkit().getImage("C:\\Users\\ASUS\\Desktop\\王者荣耀图片\\Map.jpg&…
阅读更多...
基于51单片机的音乐喷泉设计

基于51单片机的音乐喷泉设计

**单片机设计介绍&#xff0c;基于51单片机的音乐喷泉设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 基于51单片机的音乐喷泉设计是一种将音乐和水喷射效果相结合的创意设计。下面是一个简要的设计介绍&#xff1a; 硬件设…
阅读更多...
003、ArkTS开发实践

003、ArkTS开发实践

之——尝试 杂谈 学习声明式UI语法&#xff1a; 正文 1.声明式UI 1.1 声明式描述 想要什么样子就直接描述&#xff1a; 1.2 状态驱动视图更新 2.自定义组件 对页面内容进行合理抽象&#xff0c;组合基础组件&#xff0c;封装成自定义组件。 自定义子组件&#xff0c;为后续使…
阅读更多...
Leetcode211. 添加与搜索单词 - 数据结构设计

Leetcode211. 添加与搜索单词 - 数据结构设计

Every day a Leetcode 题目来源&#xff1a;211. 添加与搜索单词 - 数据结构设计 解法1&#xff1a;字典树 字典树&#xff08;前缀树&#xff09;是一种树形数据结构&#xff0c;用于高效地存储和检索字符串数据集中的键。前缀树可以用 O(∣S∣) 的时间复杂度完成如下操作…
阅读更多...
【Vue】记事本

【Vue】记事本

上一篇&#xff1a;Vue的指令 https://blog.csdn.net/m0_67930426/article/details/134599378?spm1001.2014.3001.5501 本篇所需指令&#xff1a; v- for v-model v-on v-show 目录 删除功能 添加功能 统计功能 清空功能 v-show 删除功能 <!DOCTYPE html> …
阅读更多...
原生DOM事件、react16、17和Vue合成事件

原生DOM事件、react16、17和Vue合成事件

目录 原生DOM事件 注册/绑定事件 DOM事件级别 DOM0&#xff1a;onclick传统注册&#xff1a; 唯一&#xff08;同元素的(不)同事件会覆盖&#xff09; 没有捕获和冒泡的&#xff0c;只有简单的事件绑定 DOM2&#xff1a;addEventListener监听注册&#xff1a;可添加多个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023