Java 复习笔记 - 常用API 下

文章目录

  • 一，JDK7以前时间相关类
    • （一）Date 时间
    • （二）SimpleDateFormat 格式化时间
    • （三）Calendar 日历
  • 二，JDK8新增时间相关类
    • （一）时区、时间和格式化
    • （二）日历类
    • （三）工具类
  • 三，包装类
  • 四，综合练习
    • （一）键盘录入
    • （二）简易算法题01
    • （三）简易算法题02
    • （四）简易算法题03
    • （五）简易算法题04

一，JDK7以前时间相关类

在Java JDK 7及之前的版本中，主要使用以下几个类来处理时间相关的操作：

  1. java.util.Date：Date类表示特定的时间点，通过new Date()可以创建当前时间的实例。它包含了日期和时间的信息，但它没有提供方法来操作日期和时间。

  2. java.util.Calendar：Calendar类是一个抽象类，提供了对日期和时间进行操作的方法。可以通过Calendar.getInstance()来获取当前时间的实例，并使用它来进行日期和时间的计算和操作。

  3. java.util.GregorianCalendar：GregorianCalendar类是Calendar类的一个具体实现，它用于处理Gregorian日历系统中的日期和时间。可以通过new GregorianCalendar()来创建一个GregorianCalendar的实例。

  4. java.text.DateFormat：DateFormat类用于格式化和解析日期和时间。它有多个静态方法来创建不同样式和地区的日期格式实例，例如DateFormat.getDateInstance()和DateFormat.getTimeInstance()。

  5. java.text.SimpleDateFormat：SimpleDateFormat类是DateFormat类的一个具体实现，它可以根据指定的模式字符串来格式化和解析日期和时间。可以通过new SimpleDateFormat(pattern)来创建一个SimpleDateFormat的实例，其中pattern是指定的日期时间模式。

这些类在Java JDK 7及之前提供了一些基本的日期和时间操作功能，但不够灵活和易用。从Java JDK 8开始，引入了新的日期和时间API（java.time包），提供了更强大和易用的日期和时间处理功能。

（一）Date 时间

java.util.Date是一个类，它表示特定的瞬间，精确到毫秒。这个类从1900年1月1日00:00:00 GMT开始计算时间，直到现在的时间。Date类提供了许多方法来处理日期和时间，例如getYear()、getMonth()、getDate()、getHours()、getMinutes()和getSeconds()等。但是，Date类的一个主要缺点是它不是线程安全的。

Date类的主要特点如下：

  1. 表示日期和时间：Date类可以表示从1970年1月1日00:00:00开始计算的毫秒数。它通过long类型的值来存储日期和时间。

  2. 构造方法：Date类提供了多个构造方法，用于创建不同日期和时间的实例。其中，无参构造方法将创建一个表示当前日期和时间的Date对象。

  3. 常用方法：Date类提供了一些常用的方法，例如getTime()用于获取日期的毫秒数表示，compareTo()用于比较两个日期的顺序，toString()用于将日期转换为字符串表示等。

使用Date类的示例：

import java.util.Date;// 创建表示当前日期和时间的Date对象
Date currentDate = new Date();// 获取日期的毫秒数表示
long timeInMillis = currentDate.getTime();// 比较两个日期
Date date1 = new Date(2021, 9, 1); // 注意：这里的月份是从0开始的，即9表示10月
Date date2 = new Date(2021, 9, 2);int comparison = date1.compareTo(date2);
if (comparison == 0) {System.out.println("日期相等");
} else if (comparison < 0) {System.out.println("date1在date2之前");
} else if (comparison > 0) {System.out.println("date1在date2之后");
}

练习：时间计算

需求1：打印时间原点开始1年之后的时间。
需求2：定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后。

需求1：打印时间原点开始1年之后的时间（不使用Calendar和SimpleDateFormat）。

import java.util.Date;public class TimeOrigin {public static void main(String[] args) {// 获取当前日期时间Date currentDate = new Date();// 将日期时间往后推1年long oneYearLaterMillis = currentDate.getTime() + 365 * 24 * 60 * 60 * 1000;Date oneYearLater = new Date(oneYearLaterMillis);// 打印结果System.out.println("时间原点开始1年之后的时间是：" + oneYearLater);}
}

需求2：定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后（不使用Calendar和SimpleDateFormat）。

import java.util.Date;public class CompareDates {public static void main(String[] args) {// 定义两个Date对象Date date1 = new Date(121, 8, 1); // 注意：这里的年份需要减去1900，月份从0开始的Date date2 = new Date(121, 8, 2);// 比较两个日期boolean isDate1BeforeDate2 = date1.before(date2);boolean isDate1AfterDate2 = date1.after(date2);if (isDate1BeforeDate2) {System.out.println("date1在date2之前");} else if (isDate1AfterDate2) {System.out.println("date1在date2之后");} else {System.out.println("日期相等");}}
}

（二）SimpleDateFormat 格式化时间

SimpleDateFormat是Java中用于格式化和解析日期时间的类。它可以根据指定的日期时间模式将日期时间格式化为字符串，或者将字符串解析为对应的日期时间对象。

SimpleDateFormat类使用一套预定义的模式字符来表示日期时间的格式。这些模式字符可以根据需要组合在一起，以达到所需的日期时间格式。以下是一些常用的模式字符：

  • y：年份，例如：2022
  • M：月份，例如：12（数字表示）或者Dec（英文表示）
  • d：日期，例如：31
  • H：小时（24小时制），例如：23
  • h：小时（12小时制），例如：11
  • m：分钟，例如：59
  • s：秒钟，例如：59
  • S：毫秒，例如：999

除了模式字符外，SimpleDateFormat还支持一些特殊字符和格式化选项，例如：

  • E：星期几，例如：星期一（英文表示）
  • a：上午/下午标记，例如：AM/PM
  • z：时区，例如：GMT+08:00

以下是一些示例代码，展示如何使用SimpleDateFormat类格式化日期时间：

import java.text.SimpleDateFormat;
import java.util.Date;public class SimpleDateFormatExample {public static void main(String[] args) {Date date = new Date(); // 获取当前日期时间// 格式化日期时间为字符串SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String formattedDate = sdf.format(date);System.out.println("格式化后的日期时间：" + formattedDate);// 将字符串解析为日期时间对象String dateString = "2022-12-31 23:59:59";try {Date parsedDate = sdf.parse(dateString);System.out.println("解析后的日期时间对象：" + parsedDate);} catch (Exception e) {e.printStackTrace();}}
}

在上面的示例中，我们先使用SimpleDateFormat类将当前日期时间格式化为字符串，然后再将字符串解析为日期时间对象。输出结果如下：

格式化后的日期时间：2022-12-31 23:59:59
解析后的日期时间对象：Sat Dec 31 23:59:59 CST 2022

通过SimpleDateFormat类，我们可以方便地在Java中进行日期时间的格式化和解析操作。

（三）Calendar 日历

Calendar是Java中用于处理日期和时间的抽象类。它提供了一组方法来操作和计算日期时间，并支持不同历法和时区的处理。

Calendar类提供了一系列静态方法来获取Calendar对象，例如getInstance()方法可以获取当前默认时区的Calendar对象。我们也可以使用Calendar.getInstance(TimeZone timeZone)方法来获取指定时区的Calendar对象。

Calendar类提供了许多常用的方法来获取和设置日期时间的各个部分，例如：

  • get(int field)：获取指定部分的值，例如Calendar.YEAR表示年份
  • set(int field, int value)：设置指定部分的值
  • add(int field, int amount)：在指定部分上增加或减少指定的值
  • getTime()：获取Calendar对象对应的Date对象
  • setTime(Date date)：将给定的Date对象设置为Calendar对象的日期时间

以下是一个示例代码，展示如何使用Calendar类处理日期时间：

import java.util.Calendar;public class CalendarExample {public static void main(String[] args) {Calendar calendar = Calendar.getInstance(); // 获取当前日期时间的Calendar对象// 获取年份int year = calendar.get(Calendar.YEAR);System.out.println("年份：" + year);// 设置月份为十二月calendar.set(Calendar.MONTH, Calendar.DECEMBER);int month = calendar.get(Calendar.MONTH);System.out.println("月份：" + month); // 月份从0开始，所以输出11表示十二月// 在当前日期上增加1天calendar.add(Calendar.DAY_OF_MONTH, 1);int day = calendar.get(Calendar.DAY_OF_MONTH);System.out.println("日期：" + day);// 获取当前日期时间的Date对象System.out.println("Date对象：" + calendar.getTime());}
}

在上面的示例中，我们首先使用Calendar.getInstance()方法获取当前日期时间的Calendar对象。然后，我们使用get()方法获取年份、set()方法设置月份为十二月、add()方法在当前日期上增加1天，并使用getTime()方法获取对应的Date对象。

输出结果如下：

年份：2022
月份：11
日期：21
Date对象：Sun Dec 21 11:50:56 CST 2022

通过Calendar类，我们可以方便地进行日期时间的操作和计算，包括获取、设置、增加和减少不同部分的值。它是Java中处理日期时间的重要工具类。

二，JDK8新增时间相关类

在JDK 8中，Java新增了一组全新的时间相关类，这些类位于java.time包中，用于更方便、更易于使用地处理日期、时间和时间间隔。以下是JDK 8中新增的一些重要的时间相关类：

  1. LocalDate：表示日期，不包含具体时间和时区信息。它提供了许多方法来处理日期，例如获取年、月、日等。
  2. LocalTime：表示时间，不包含具体日期和时区信息。它提供了许多方法来处理时间，例如获取小时、分钟、秒等。
  3. LocalDateTime：表示日期时间，不包含时区信息。它是LocalDate和LocalTime的组合，提供了处理日期和时间的方法。
  4. Instant：表示时间线上的一个点，精确到纳秒级别。它可以用于计算时间间隔和执行时间的比较。
  5. Duration：表示时间间隔，可以用于计算两个时间点之间的差值，精确到纳秒级别。
  6. Period：表示日期间隔，可以用于计算两个日期之间的差值，精确到天。
  7. ZoneId：表示时区的标识符，用于表示不同的时区。
  8. ZonedDateTime：表示带时区的日期时间，是LocalDateTime和ZoneId的组合。
  9. DateTimeFormatter：用于格式化和解析日期时间。

这些新的时间相关类提供了更加简洁和易用的API，使得处理日期、时间和时间间隔变得更加直观和便捷。同时，它们也支持更多的操作和功能，例如时区的处理、日期时间的格式化和解析等。

以下是一个示例代码，展示如何使用JDK 8中新增的时间相关类：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Instant;
import java.time.Duration;
import java.time.Period;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;public class DateTimeExample {public static void main(String[] args) {// LocalDate示例LocalDate date = LocalDate.now();System.out.println("日期：" + date);// LocalTime示例LocalTime time = LocalTime.now();System.out.println("时间：" + time);// LocalDateTime示例LocalDateTime dateTime = LocalDateTime.now();System.out.println("日期时间：" + dateTime);// Instant示例Instant instant = Instant.now();System.out.println("时间戳：" + instant);// Duration示例Instant start = Instant.now();// 模拟一些耗时操作try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}Instant end = Instant.now();Duration duration = Duration.between(start, end);System.out.println("耗时：" + duration.toMillis() + "毫秒");// Period示例LocalDate date1 = LocalDate.of(2022, 1, 1);LocalDate date2 = LocalDate.of(2022, 12, 31);Period period = Period.between(date1, date2);System.out.println("日期间隔：" + period.getMonths() + "个月");// ZoneId和ZonedDateTime示例ZoneId zoneId = ZoneId.of("Asia/Shanghai");ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId);System.out.println("带时区的日期时间：" + zonedDateTime);// DateTimeFormatter示例DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String formattedDateTime = dateTime.format(formatter);System.out.println("格式化后的日期时间：" + formattedDateTime);}
}

在上面的示例中，我们使用了JDK 8中的LocalDate、LocalTime、LocalDateTime、Instant、Duration、Period、ZoneId、ZonedDateTime和DateTimeFormatter等类来处理日期、时间和时间间隔，并展示了它们的一些常用方法和功能。

输出结果如下：

日期：2022-12-21
时间：12:34:56.123456789
日期时间：2022-12-21T12:34:56.123456789
时间戳：2022-12-21T04:56:33.123Z
耗时：2001毫秒
日期间隔：11个月
带时区的日期时间：2022-12-21T12:34:56.123456789+08:00[Asia/Shanghai]
格式化后的日期时间：2022-12-21 12:34:56

通过使用JDK 8中的时间相关类，我们可以更加方便地处理日期、时间和时间间隔，并进行更多的操作和计算。这些新的类提供了更加强大和易用的API，是Java中处理时间的重要工具。

（一）时区、时间和格式化

在JDK 8中引入了新的日期时间API，它提供了用于处理时区、时间和格式化的类。以下是对这些类的简要介绍：

  1. 时区（ZoneId）：时区类用于表示不同时区。它提供了静态方法来获取系统默认时区和根据时区ID获取特定时区的方法。

  2. 日期时间（LocalDateTime）：日期时间类用于表示不带时区的日期和时间。它提供了许多方法来获取和操作日期和时间的各个部分。

  3. 格式化器（DateTimeFormatter）：格式化器类用于格式化和解析日期、时间和日期时间。它提供了许多预定义的格式化模式，也可以根据自定义模式创建格式化器。

在JDK 8中，Java引入了新的时间相关类来处理时区、时间和格式化。以下是如何在JDK 8中处理时区、时间和格式化的示例：

  1. 时区（ZoneId）：
import java.time.ZoneId;// 获取系统默认时区
ZoneId defaultZone = ZoneId.systemDefault();
System.out.println("系统默认时区：" + defaultZone);// 获取指定时区
ZoneId zone = ZoneId.of("Asia/Shanghai");
System.out.println("指定时区：" + zone);
  1. 时间（LocalTime）：
import java.time.LocalTime;// 获取当前时间
LocalTime time = LocalTime.now();
System.out.println("当前时间：" + time);// 创建指定时间
LocalTime specificTime = LocalTime.of(12, 30, 0);
System.out.println("指定时间：" + specificTime);
  1. 格式化与解析（DateTimeFormatter）：
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;// 创建DateTimeFormatter对象
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");// 格式化日期时间
LocalDateTime dateTime = LocalDateTime.now();
String formattedDateTime = dateTime.format(formatter);
System.out.println("格式化后的日期时间：" + formattedDateTime);// 解析日期时间
String dateTimeStr = "2022-12-21 12:34:56";
LocalDateTime parsedDateTime = LocalDateTime.parse(dateTimeStr, formatter);
System.out.println("解析后的日期时间：" + parsedDateTime);

输出结果如下：

系统默认时区：Asia/Shanghai
指定时区：Asia/Shanghai
当前时间：12:34:56.123
指定时间：12:30:00
格式化后的日期时间：2022-12-21 12:34:56
解析后的日期时间：2022-12-21T12:34:56

通过使用JDK 8中的时区、时间和格式化相关类，我们可以轻松地处理不同时区的时间，进行时间的格式化和解析。这些新的类提供了简单易用的API，使得处理时区、时间和格式化变得更加方便和灵活。

新的日期时间API相比于旧的Date和Calendar类具有更多的优势，包括：

  • 不可变性：日期时间类是不可变的，这意味着它们是线程安全的，并且可以方便地在多线程环境中使用。
  • 易读性：日期时间类的方法名和参数更加清晰和易读，使得代码更易于理解和维护。
  • 扩展性：新的日期时间API提供了更多的功能和灵活性，例如处理时区和格式化的支持。

总而言之，JDK 8中的新日期时间API提供了更好的方式来处理时区、时间和格式化。它们更加易于使用和理解，并且提供了更多的功能和扩展性。如果你在项目中需要处理日期、时间相关的操作，推荐使用JDK 8中的日期时间API来替代旧的Date和Calendar类。

（二）日历类

在JDK 8中，Calendar类是一个用于操作日期和时间的日历类。它是一个抽象类，提供了一些方法来获取和设置日期、时间、日期字段等。

Calendar类的主要功能包括以下几个方面：

  1. 获取Calendar对象：可以使用Calendar类的静态方法getInstance()来获取一个Calendar对象，该对象使用默认的时区和语言环境。

  2. 设置日期和时间：可以使用set()方法来设置Calendar对象的年、月、日等字段的值。

  3. 获取日期和时间：可以使用get()方法来获取Calendar对象的年、月、日等字段的值。

  4. 日期计算：可以使用add()方法来对日期进行加减操作。例如，可以将日期加上一天，或减去一个月。

  5. 日期比较：可以使用compareTo()方法来比较两个日期的先后顺序。

  6. 日期字段：Calendar类提供了一些常量来表示日期的各个字段，如YEAR、MONTH、DAY_OF_MONTH、HOUR等。

需要注意的是，Calendar类中的月份字段是从0开始的，即0表示一月，11表示十二月。这是因为历史原因导致的设计问题，可能会给使用者带来一些困惑。

虽然Calendar类可以用来进行日期和时间的操作，但它存在一些设计上的问题，比如月份从0开始、可变性等。因此，在JDK 8中引入了新的日期时间类，如LocalDate、LocalTime和LocalDateTime，它们更推荐用来处理日期和时间的操作。

下面是一个简单的示例，展示了如何使用Calendar类来获取和设置日期、时间的示例：

import java.util.Calendar;public class CalendarExample {public static void main(String[] args) {// 获取当前日期和时间Calendar calendar = Calendar.getInstance();System.out.println("当前日期和时间：" + calendar.getTime());// 设置日期和时间calendar.set(Calendar.YEAR, 2022);calendar.set(Calendar.MONTH, Calendar.JANUARY);calendar.set(Calendar.DAY_OF_MONTH, 1);calendar.set(Calendar.HOUR_OF_DAY, 12);calendar.set(Calendar.MINUTE, 0);calendar.set(Calendar.SECOND, 0);System.out.println("设置后的日期和时间：" + calendar.getTime());// 获取日期和时间的字段值int year = calendar.get(Calendar.YEAR);int month = calendar.get(Calendar.MONTH);int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);int hourOfDay = calendar.get(Calendar.HOUR_OF_DAY);int minute = calendar.get(Calendar.MINUTE);int second = calendar.get(Calendar.SECOND);System.out.println("年份：" + year);System.out.println("月份：" + (month + 1)); // 注意月份要加1System.out.println("日期：" + dayOfMonth);System.out.println("小时：" + hourOfDay);System.out.println("分钟：" + minute);System.out.println("秒钟：" + second);// 日期计算calendar.add(Calendar.DAY_OF_MONTH, 1); // 增加一天System.out.println("增加一天后的日期：" + calendar.getTime());// 日期比较Calendar anotherCalendar = Calendar.getInstance();anotherCalendar.set(Calendar.YEAR, 2022);anotherCalendar.set(Calendar.MONTH, Calendar.JANUARY);anotherCalendar.set(Calendar.DAY_OF_MONTH, 2);int result = calendar.compareTo(anotherCalendar);if (result == 0) {System.out.println("两个日期相等");} else if (result < 0) {System.out.println("当前日期早于另一个日期");} else {System.out.println("当前日期晚于另一个日期");}}
}

上述示例演示了如何使用Calendar类来获取当前日期和时间、设置日期和时间、获取日期和时间的字段值、进行日期计算和比较等操作。需要注意的是，月份字段是从0开始的，所以要注意加1才是实际的月份。

总结来说，Calendar类是一个用于操作日期和时间的日历类，可以用来获取和设置日期、时间、日期字段等。但在JDK 8中，更推荐使用新的日期时间类来进行日期和时间的操作。

（三）工具类

在JDK 8中，有一个名为java.time的全新日期和时间API，它提供了一系列的日期、时间和时间间隔的类，用于更方便地处理日期和时间的操作。下面是一些常用的时间工具类的简介：

  1. LocalDate：表示一个日期，不包含时间和时区信息。
  2. LocalTime：表示一个时间，不包含日期和时区信息。
  3. LocalDateTime：表示一个日期和时间，不包含时区信息。
  4. ZonedDateTime：表示一个带时区的日期和时间。
  5. Instant：表示一个时间戳，也就是从1970年1月1日午夜（格林威治时间）开始的秒数。
  6. Duration：表示一个时间段，可以用于计算两个时间点之间的间隔。
  7. Period：表示一个日期段，可以用于计算两个日期之间的间隔。
  8. DateTimeFormatter：用于格式化和解析日期和时间的类。
  9. TemporalAdjuster：用于调整日期和时间的类，如获取下一个周一的日期。

这些类提供了丰富的方法和操作，可以方便地进行日期和时间的计算、比较和格式化等操作。使用这些类可以简化代码，提高代码的可读性和可维护性。

下面是一个示例，展示了如何使用java.time包中的类来进行日期和时间的操作：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.time.Instant;
import java.time.Duration;
import java.time.Period;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAdjusters;public class DateTimeExample {public static void main(String[] args) {// 获取当前日期和时间LocalDate currentDate = LocalDate.now();LocalTime currentTime = LocalTime.now();LocalDateTime currentDateTime = LocalDateTime.now();System.out.println("当前日期：" + currentDate);System.out.println("当前时间：" + currentTime);System.out.println("当前日期和时间：" + currentDateTime);// 创建指定日期和时间LocalDate date = LocalDate.of(2022, 1, 1);LocalTime time = LocalTime.of(12, 0, 0);LocalDateTime dateTime = LocalDateTime.of(date, time);System.out.println("指定日期：" + date);System.out.println("指定时间：" + time);System.out.println("指定日期和时间：" + dateTime);// 获取当前时区的日期和时间ZonedDateTime zonedDateTime = ZonedDateTime.now();System.out.println("当前时区日期和时间：" + zonedDateTime);// 获取时间戳Instant instant = Instant.now();System.out.println("当前时间戳：" + instant);// 计算时间间隔LocalDateTime startDateTime = LocalDateTime.of(2022, 1, 1, 0, 0, 0);LocalDateTime endDateTime = LocalDateTime.of(2022, 1, 2, 12, 0, 0);Duration duration = Duration.between(startDateTime, endDateTime);System.out.println("时间间隔：" + duration);// 计算日期间隔LocalDate startDate = LocalDate.of(2022, 1, 1);LocalDate endDate = LocalDate.of(2022, 1, 31);Period period = Period.between(startDate, endDate);System.out.println("日期间隔：" + period.getMonths() + "个月" + period.getDays() + "天");// 格式化日期和时间LocalDateTime formattedDateTime = LocalDateTime.of(2022, 1, 1, 12, 0, 0);DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");String formattedString = formattedDateTime.format(formatter);System.out.println("格式化后的日期和时间：" + formattedString);// 调整日期和时间LocalDate adjustDate = LocalDate.of(2022, 1, 1);LocalDate nextMonday = adjustDate.with(TemporalAdjusters.next(DayOfWeek.MONDAY));System.out.println("下一个周一的日期：" + nextMonday);}
}

上述示例演示了如何使用java.time包中的类来创建和操作日期和时间，包括获取当前日期和时间、创建指定的日期和时间、获取当前时区的日期和时间、获取时间戳、计算时间间隔和日期间隔、格式化日期和时间以及调整日期和时间等操作。可以根据自己的需求来选择合适的时间工具类，以简化代码并提高开发效率。

三，包装类

在Java中，包装类（Wrapper Class）是一种将基本数据类型转换为对象的方式。Java提供了8个基本数据类型对应的包装类，分别为：

  1. Boolean：对应boolean类型。
  2. Byte：对应byte类型。
  3. Short：对应short类型。
  4. Integer：对应int类型。
  5. Long：对应long类型。
  6. Float：对应float类型。
  7. Double：对应double类型。
  8. Character：对应char类型。

包装类提供了一系列的方法和属性，用于操作和获取基本数据类型的值。它们还提供了一些静态方法，用于将字符串转换为相应的基本数据类型。

包装类的主要作用有以下几点：

  1. 提供了对象化的方式来处理基本数据类型，方便与其他对象进行交互。
  2. 在集合类中，只能存储对象，无法直接存储基本数据类型，因此可以使用包装类来包装基本数据类型，然后存储到集合中。
  3. 在某些情况下，需要将基本数据类型作为方法参数进行传递，但方法的参数只能是对象，此时可以使用包装类来包装基本数据类型。

使用包装类的一般步骤如下：

  1. 创建包装类对象，并传入基本数据类型的值。
  2. 使用包装类对象中的方法和属性进行操作和获取基本数据类型的值。

以下是一个示例，演示了如何使用包装类：

public class WrapperExample {public static void main(String[] args) {// 包装类的创建和基本数据类型的转换Integer i = Integer.valueOf(10);int j = i.intValue();System.out.println("包装类的值：" + i);System.out.println("基本数据类型的值：" + j);// 包装类的属性和方法System.out.println("包装类的最大值：" + Integer.MAX_VALUE);System.out.println("包装类的最小值：" + Integer.MIN_VALUE);System.out.println("包装类的二进制表示：" + Integer.toBinaryString(i));System.out.println("包装类的十六进制表示：" + Integer.toHexString(i));System.out.println("包装类的字符串表示：" + i.toString());// 字符串转换为包装类对象Integer k = Integer.parseInt("20");System.out.println("字符串转换为包装类对象：" + k);// 包装类作为方法参数printNumber(k);}public static void printNumber(Integer number) {System.out.println("包装类作为方法参数：" + number);}
}

上述示例展示了如何使用包装类，包括创建包装类对象、获取基本数据类型的值、使用包装类的属性和方法、将字符串转换为包装类对象以及将包装类作为方法参数进行传递等操作。通过包装类，可以更方便哦豁,我回答出错了耶~ 你重新试一试呗~

四，综合练习

（一）键盘录入

需求：键盘录入一些1~100之间的整数，并添加到集合中，直到集合中的所有数据和超过200为止。

以下是一个示例代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;public class Exercise {public static void main(String[] args) {List<Integer> numbers = new ArrayList<>();int sum = 0;Scanner scanner = new Scanner(System.in);while (sum <= 200) {System.out.print("请输入一个1~100之间的整数：");int number = scanner.nextInt();if (number >= 1 && number <= 100) {numbers.add(number);sum += number;} else {System.out.println("输入的数字不在1~100之间，请重新输入。");}}System.out.println("集合中的数据为：" + numbers);System.out.println("集合中的数据和为：" + sum);scanner.close();}
}

运行上述代码后，程序会提示你输入一个1~100之间的整数。如果输入的数字符合要求，则会将该数字添加到集合中，并更新集合中的数据和。如果输入的数字不符合要求，则会提示重新输入。当集合中的数据和超过200时，程序会停止录入，并输出集合中的数据和。

（二）简易算法题01

需求：自己实现parseInt方法的效果，将字符串形式的数据转成整数，字符串中只能是数字不能有其他字符，最少1位最多10位，0不能开头。

以下是一个示例代码：

public class Exercise {public static void main(String[] args) {String str1 = "12345";String str2 = "9876543210";String str3 = "0123";String str4 = "abc123";int num1 = myParseInt(str1);int num2 = myParseInt(str2);int num3 = myParseInt(str3);int num4 = myParseInt(str4);System.out.println("转换结果：" + num1); // 输出：转换结果：12345System.out.println("转换结果：" + num2); // 输出：转换结果：-1System.out.println("转换结果：" + num3); // 输出：转换结果：-1System.out.println("转换结果：" + num4); // 输出：转换结果：-1}public static int myParseInt(String str) {int result = 0;int length = str.length();// 判断字符串长度是否符合要求if (length < 1 || length > 10) {return -1; // 返回-1表示转换失败}// 判断字符串是否以0开头if (str.charAt(0) == '0') {return -1; // 返回-1表示转换失败}// 遍历字符串每个字符并计算整数值for (int i = 0; i < length; i++) {char c = str.charAt(i);// 判断字符是否为数字if (c < '0' || c > '9') {return -1; // 返回-1表示转换失败}// 计算整数值result = result * 10 + (c - '0');}return result;}
}

上述代码中，定义了一个名为myParseInt的方法，该方法接收一个字符串作为参数，并尝试将其转换为整数。首先，判断字符串的长度是否满足要求（1到10位），然后判断字符串是否以0开头。接下来，遍历字符串中的每个字符，判断是否为数字，并使用等式result = result * 10 + (c - '0')计算整数值。如果遇到不满足要求的情况，例如字符串中包含非数字字符或者不满足长度要求，返回-1表示转换失败。最后，在main方法中测试了几个例子，验证了自定义的myParseInt方法的效果。

（三）简易算法题02

需求：定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转换成字符串表示的二进制（除基取余法）。

以下是一个示例代码：

public class Exercise {public static void main(String[] args) {int num1 = 10;int num2 = 23;int num3 = 45;String binaryString1 = myToBinaryString(num1);String binaryString2 = myToBinaryString(num2);String binaryString3 = myToBinaryString(num3);System.out.println("二进制表示：" + binaryString1); // 输出：二进制表示：1010System.out.println("二进制表示：" + binaryString2); // 输出：二进制表示：10111System.out.println("二进制表示：" + binaryString3); // 输出：二进制表示：101101}public static String myToBinaryString(int num) {if (num == 0) {return "0";}StringBuilder sb = new StringBuilder();while (num > 0) {int remainder = num % 2;sb.append(remainder);num = num / 2;}return sb.reverse().toString();}
}

上述代码中，定义了一个名为myToBinaryString的方法，该方法接收一个十进制整数作为参数，并将其转换为字符串表示的二进制。使用了除基取余法来实现转换。首先，判断如果输入的整数为0，则直接返回字符串"0"。接下来，创建了一个StringBuilder对象sb来存储计算结果。使用一个循环，每次将整数除以2并取得余数，然后将余数添加到sb中。最后，将sb对象反转并转换为字符串，返回转换结果。

在main方法中，测试了几个例子，验证了自定义的myToBinaryString方法的效果。

（四）简易算法题03

需求：请使用代码实现计算你活了多少天，用JDK7和JDK8两种方式完成。

以下是示例代码：

JDK7方式：

import java.util.Calendar;public class Exercise {public static void main(String[] args) {int yearOfBirth = 1990;int monthOfBirth = 5;int dayOfBirth = 15;int currentYear = Calendar.getInstance().get(Calendar.YEAR);int currentMonth = Calendar.getInstance().get(Calendar.MONTH) + 1;int currentDay = Calendar.getInstance().get(Calendar.DAY_OF_MONTH);int ageInDays = calculateAgeInDaysJDK7(yearOfBirth, monthOfBirth, dayOfBirth, currentYear, currentMonth, currentDay);System.out.println("你活了 " + ageInDays + " 天");}public static int calculateAgeInDaysJDK7(int birthYear, int birthMonth, int birthDay, int currentYear, int currentMonth, int currentDay) {int days = 0;// 计算整年的天数for (int year = birthYear; year < currentYear; year++) {days += isLeapYear(year) ? 366 : 365;}// 计算当前年的天数days += calculateDaysInYearJDK7(birthYear, birthMonth, birthDay, currentYear, currentMonth, currentDay);return days;}public static int calculateDaysInYearJDK7(int birthYear, int birthMonth, int birthDay, int currentYear, int currentMonth, int currentDay) {int days = 0;// 计算整月的天数for (int month = birthMonth; month <= 12; month++) {days += calculateDaysInMonthJDK7(birthYear, month);}// 计算当前月的天数days -= birthDay - 1;days += currentDay;// 计算中间年份的天数for (int year = birthYear + 1; year < currentYear; year++) {for (int month = 1; month <= 12; month++) {days += calculateDaysInMonthJDK7(year, month);}}// 减去当前年的多余天数for (int month = currentMonth + 1; month <= 12; month++) {days -= calculateDaysInMonthJDK7(currentYear, month);}return days;}public static int calculateDaysInMonthJDK7(int year, int month) {switch (month) {case 1: case 3: case 5: case 7: case 8: case 10: case 12:return 31;case 4: case 6: case 9: case 11:return 30;case 2:return isLeapYear(year) ? 29 : 28;default:return 0;}}public static boolean isLeapYear(int year) {return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);}
}

JDK8方式：

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;public class Exercise {public static void main(String[] args) {int yearOfBirth = 1990;int monthOfBirth = 5;int dayOfBirth = 15;LocalDate birthDate = LocalDate.of(yearOfBirth, monthOfBirth, dayOfBirth);LocalDate currentDate = LocalDate.now();long ageInDays = calculateAgeInDaysJDK8(birthDate, currentDate);System.out.println("你活了 " + ageInDays + " 天");}public static long calculateAgeInDaysJDK8(LocalDate birthDate, LocalDate currentDate) {return ChronoUnit.DAYS.between(birthDate, currentDate);}
}

上述代码中，定义了一个计算活了多少天的方法calculateAgeInDaysJDK7和calculateAgeInDaysJDK8。在JDK7方式中，通过循环来计算整年、整月和当前年的天数，并使用calculateDaysInMonthJDK7方法来计算每个月的天数。在JDK8方式中，使用LocalDate类来表示日期，并使用ChronoUnit.DAYS.between方法来计算两个日期之间的天数。

在main方法中，测试了一个例子，计算了从1990年5月15日到当前日期的天数，并输出结果。

（五）简易算法题04

需求：判断任意一个年份是闰年还是平年，使用JDK7和JDK8两种方式判断。
提示：二月有29天的是闰年，一年有366天是闰年。

以下是示例代码：

JDK7方式：

public class Exercise {public static void main(String[] args) {int year = 2020;boolean isLeapYear = isLeapYearJDK7(year);if (isLeapYear) {System.out.println(year + "年是闰年");} else {System.out.println(year + "年是平年");}}public static boolean isLeapYearJDK7(int year) {return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);}
}

JDK8方式：

import java.time.Year;public class Exercise {public static void main(String[] args) {int year = 2020;boolean isLeapYear = isLeapYearJDK8(year);if (isLeapYear) {System.out.println(year + "年是闰年");} else {System.out.println(year + "年是平年");}}public static boolean isLeapYearJDK8(int year) {return Year.of(year).isLeap();}
}

上述代码中，定义了一个判断年份是否为闰年的方法isLeapYearJDK7和isLeapYearJDK8。在JDK7方式中，使用了条件判断的方式来判断年份是否能被4整除但不能被100整除，或者能被400整除。在JDK8方式中，使用了Year类的isLeap()方法来判断年份是否为闰年。

在main方法中，测试了一个例子，判断了2020年是否为闰年，并输出结果。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/78267.shtml

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

相关文章

Layui + Flask 使用（01）

Layui + Flask 使用（01）

Layui 是一套开源免费的 Web UI 组件库，采用自身轻量级模块化规范，遵循原生态的 HTML/CSS/JavaScript 开发模式，极易上手，拿来即用，非常适合网页界面的快速构建。在使用了很久之后，也发现了一些问题。 先说优点： layui 采用的是原生的 HTML/CSS/JavaScript 技术开发，上…
阅读更多...
R-YOLOv7-tiny检测浸水玉米胚乳裂纹

R-YOLOv7-tiny检测浸水玉米胚乳裂纹

Detecting endosperm cracks in soaked maize using μCT technology and R-YOLOv7-tiny 1、模型1.1 C3_TR module（自己提出修改）1.2 CoT block注意力1.3 GhostConv模块2、模型整体流程图3、实验采用r - yolov7微模型和μCT技术对浸水玉米胚乳裂纹进行了检测。提出的ryolov7微…
阅读更多...
Nginx参数配置详细说明【全局、http块、server块、events块】【已亲测】

Nginx参数配置详细说明【全局、http块、server块、events块】【已亲测】

Nginx重点参数配置说明 本文包含Nginx参数配置说明全局块、http块、server块、events块共计30多个参数配置与解释&#xff0c;其中常见参数包含配置错误出现的错误日志&#xff0c;能让你更快的解决问题。 该文的所有参数大部分经过单独测试&#xff0c;错误都是自己收集出来的…
阅读更多...
iOS开发 蓝牙功能

iOS开发 蓝牙功能

iOS开发蓝牙功能主要分扫描中心和外设设备 Central: 中心设备,发起蓝牙连接的设备(一般指手机)Peripheral: 外设,被蓝牙连接的设备(一般是运动手环/蓝牙模块)Service:服务,每个设备会提供服务,一个设备有很多服务Characteristic:特征,每个服务中包含很多个特征,这些特征的权限…
阅读更多...
付费进群搭建二维码

付费进群搭建二维码

如今&#xff0c;在互联网时代&#xff0c;群组聊天已经成为人们高效沟通和合作的重要方式。然而&#xff0c;对于一些专业团队或机构来说&#xff0c;免费的系统可能无法满足他们对安全性、稳定性和个性化功能的要求。因此&#xff0c;他们需要寻找付费的群组系统&#xff0c;…
阅读更多...
如何将安防视频监控系统/视频云存储EasyCVR平台推流到公网直播间？

如何将安防视频监控系统/视频云存储EasyCVR平台推流到公网直播间？

视频云存储/安防监控EasyCVR视频汇聚平台基于云边端智能协同&#xff0c;支持海量视频的轻量化接入与汇聚、转码与处理、全网智能分发、视频集中存储等。音视频流媒体视频平台EasyCVR拓展性强&#xff0c;视频能力丰富&#xff0c;具体可实现视频监控直播、视频轮播、视频录像、…
阅读更多...
基于PyTorch使用LSTM实现新闻文本分类任务

基于PyTorch使用LSTM实现新闻文本分类任务

本文参考 PyTorch深度学习项目实战100例 https://weibaohang.blog.csdn.net/article/details/127154284?spm1001.2014.3001.5501 文章目录 本文参考任务介绍做数据的导入 环境介绍导入必要的包介绍torchnet和keras做数据的导入给必要的参数命名加载文本数据数据前处理模型训…
阅读更多...
防火墙概述及实战

防火墙概述及实战

目录 前言 一、概述 &#xff08;一&#xff09;、防火墙分类 &#xff08;二&#xff09;、防火墙性能 &#xff08;三&#xff09;、iptables &#xff08;四&#xff09;、iptables中表的概念 二、iptables规则匹配条件分类 &#xff08;一&#xff09;、基本匹配条…
阅读更多...
echarts常用参数详解汇总（饼图，柱形图，折线图）持续更新中

echarts常用参数详解汇总（饼图，柱形图，折线图）持续更新中

常用配置&#xff1a; X/Y轴线的基础设置《通用》 细微的差距只能去官网查看了&#xff0c;基本一致 这里只是做了个汇总方便查看 xAxis/yAxis: {show:false, // 不显示坐标轴线、坐标轴刻度线和坐标轴上的文字axisTick:{// 不显示坐标轴刻度线show:false, alignWithLabel: tru…
阅读更多...
sklearn中的数据集使用

sklearn中的数据集使用

导库 from sklearn.datasets import load_iris 实现 # 加载数据集 iris load_iris() print(f查看数据集&#xff1a;{iris}) print(f查看数据集的特征&#xff1a;{iris.feature_names}) print(f查看数据集的标签&#xff1a;{iris.target_names}) print(f查看数据集的描述…
阅读更多...
看板管理：以可视化方式确定任务优先级

看板管理：以可视化方式确定任务优先级

确定工作的优先级是我们今天都要面对的挑战。若处理不当&#xff0c;我们就可能试图一心多用&#xff0c;从而严重损害工作效率。 使用看板方法来设定工作优先级是一种非常直观、快速的方法。 确定工作优先级的看板方法 看板工作流程管理方法的核心在于工作可视化。工作被划…
阅读更多...
linux学习总结

linux学习总结

shell 1.在文本环境下&#xff0c;shell作为命令解释器&#xff0c;建立了用户和操作系统之间的接口。当用户键入一个命令时&#xff0c;shell将对该命令进行解释&#xff0c;并调用相应的程序。2.Linux下有多个shell&#xff0c;最常用的3个shell: bash tcsh zsh3.shell …
阅读更多...
hive3升级

hive3升级

文章目录 一、hive2升级到hive3步骤1.备份hive2元数据库2.导入到hive3对应的hive元数据表3.更新hive_metastore数据表信息3.1需要新增的表3.2需要更新字段的表3.3需要更改数据的表 4.hive3上集群需要的操作4.1更改元数据对应的库名4.2重启HiveMetaStore对应服务 二、hive3新特性…
阅读更多...
Elasticsearch：什么是生成式人工智能？

Elasticsearch：什么是生成式人工智能？

生成式人工智能定义 给学生的解释&#xff08;基本&#xff09;&#xff1a; 生成式人工智能是一种可以创造新的原创内容的技术&#xff0c;例如艺术、音乐、软件代码和写作。 当用户输入提示时&#xff0c;人工智能会根据从互联网上现有示例中学到的知识生成响应&#xff0c;…
阅读更多...
记录vite下使用require报错和解决办法

记录vite下使用require报错和解决办法

前情提要 我们现在项目用的是vite4react18开发的项目、但是最近公司有个睿智的人让我把webpack中的bpmn组件迁移过来、结果就出现问题啦&#xff1a;因为webpack是commonjs规范、但是vite不是、好像是es吧、可想而知各种报错 废话不多说啦 直接上代码&#xff1a; 注释是之前c…
阅读更多...
【Spring】手动实现Spring底层机制-问题的引出

【Spring】手动实现Spring底层机制-问题的引出

&#x1f384;欢迎来到边境矢梦的csdn博文&#x1f384; &#x1f384;本文主要梳理手动实现Spring底层机制-问题的引出 &#x1f384; &#x1f308;我是边境矢梦&#xff0c;一个正在为秋招和算法竞赛做准备的学生&#x1f308; &#x1f386;喜欢的朋友可以关注一下&#x1…
阅读更多...
工厂设计模式

工厂设计模式

github&#xff1a;GitHub - QiuliangLee/pattern: 设计模式 概念 根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式&#xff0c;根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。 简单工厂模式、工厂方法模式和抽象工厂模式有何区别&#xff1f; - 知…
阅读更多...
一点整理

一点整理

&#xff08;1&#xff09; 美国在2010年以后开始流行数字化转型的。 在2010年以前&#xff0c; 2006年社交网络FB “YOU”&#xff1a;在2004-2006 Web2.0热之前&#xff0c;企业是无法直接触达到每个消费者的2006年Amazon电子商务&#xff1a;这个是我瞎凑的&#xff0c;但因…
阅读更多...
运算放大器学习笔记

运算放大器学习笔记

目录 一、基本定理二、基本定义三、负反馈电路四、同向放大电路五、反向放大电路六、差分放大电路 一、基本定理 【电路示意图】 开环放大公式 VOAvo(V-V-) 开环放大倍数&#xff08;增益&#xff09;非常大&#xff0c;105 或 106 输入阻抗超级大&#xff08;可以理解为电…
阅读更多...
Spring Boot自动装配原理

Spring Boot自动装配原理

简介 Spring Boot是一个开源的Java框架&#xff0c;旨在简化Spring应用程序的搭建和开发。它通过自动装配的机制&#xff0c;大大减少了繁琐的配置工作&#xff0c;提高了开发效率。本文将深入探讨Spring Boot的自动装配原理。 自动装配的概述 在传统的Spring框架中&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023