Java 复习笔记 - 常用API 下
文章目录
- 一，JDK7以前时间相关类
-
- （一）Date 时间
- （二）SimpleDateFormat 格式化时间
- （三）Calendar 日历
- 二，JDK8新增时间相关类
-
- （一）时区、时间和格式化
- （二）日历类
- （三）工具类
- 三，包装类
- 四，综合练习
-
- （一）键盘录入
- （二）简易算法题01
- （三）简易算法题02
- （四）简易算法题03
- （五）简易算法题04
一，JDK7以前时间相关类
在Java JDK 7及之前的版本中，主要使用以下几个类来处理时间相关的操作：
-
java.util.Date：Date类表示特定的时间点，通过new Date()可以创建当前时间的实例。它包含了日期和时间的信息，但它没有提供方法来操作日期和时间。 -
java.util.Calendar：Calendar类是一个抽象类，提供了对日期和时间进行操作的方法。可以通过Calendar.getInstance()来获取当前时间的实例，并使用它来进行日期和时间的计算和操作。 -
java.util.GregorianCalendar：GregorianCalendar类是Calendar类的一个具体实现，它用于处理Gregorian日历系统中的日期和时间。可以通过new GregorianCalendar()来创建一个GregorianCalendar的实例。 -
java.text.DateFormat：DateFormat类用于格式化和解析日期和时间。它有多个静态方法来创建不同样式和地区的日期格式实例，例如DateFormat.getDateInstance()和DateFormat.getTimeInstance()。 -
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类的主要特点如下：
-
表示日期和时间：
Date类可以表示从1970年1月1日00:00:00开始计算的毫秒数。它通过long类型的值来存储日期和时间。 -
构造方法：
Date类提供了多个构造方法，用于创建不同日期和时间的实例。其中，无参构造方法将创建一个表示当前日期和时间的Date对象。 -
常用方法：
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：年份，例如：2022M：月份，例如：12（数字表示）或者Dec（英文表示）d：日期，例如：31H：小时（24小时制），例如：23h：小时（12小时制），例如：11m：分钟，例如：59s：秒钟，例如：59S：毫秒，例如：999
除了模式字符外，SimpleDateFormat还支持一些特殊字符和格式化选项，例如：
E：星期几，例如：星期一（英文表示）a：上午/下午标记，例如：AM/PMz：时区，例如：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中新增的一些重要的时间相关类：
LocalDate：表示日期，不包含具体时间和时区信息。它提供了许多方法来处理日期，例如获取年、月、日等。LocalTime：表示时间，不包含具体日期和时区信息。它提供了许多方法来处理时间，例如获取小时、分钟、秒等。LocalDateTime：表示日期时间，不包含时区信息。它是LocalDate和LocalTime的组合，提供了处理日期和时间的方法。Instant：表示时间线上的一个点，精确到纳秒级别。它可以用于计算时间间隔和执行时间的比较。Duration：表示时间间隔，可以用于计算两个时间点之间的差值，精确到纳秒级别。Period：表示日期间隔，可以用于计算两个日期之间的差值，精确到天。ZoneId：表示时区的标识符，用于表示不同的时区。ZonedDateTime：表示带时区的日期时间，是LocalDateTime和ZoneId的组合。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，它提供了用于处理时区、时间和格式化的类。以下是对这些类的简要介绍：
-
时区（ZoneId）：时区类用于表示不同时区。它提供了静态方法来获取系统默认时区和根据时区ID获取特定时区的方法。
-
日期时间（LocalDateTime）：日期时间类用于表示不带时区的日期和时间。它提供了许多方法来获取和操作日期和时间的各个部分。
-
格式化器（DateTimeFormatter）：格式化器类用于格式化和解析日期、时间和日期时间。它提供了许多预定义的格式化模式，也可以根据自定义模式创建格式化器。
在JDK 8中，Java引入了新的时间相关类来处理时区、时间和格式化。以下是如何在JDK 8中处理时区、时间和格式化的示例：
- 时区（ZoneId）：
import java.time.ZoneId;
// 获取系统默认时区
ZoneId defaultZone = ZoneId.systemDefault();
System.out.println("系统默认时区：" + defaultZone);
// 获取指定时区
ZoneId zone = ZoneId.of("Asia/Shanghai");
System.out.println("指定时区：" + zone);
- 时间（LocalTime）：
import java.time.LocalTime;
// 获取当前时间
LocalTime time = LocalTime.now();
System.out.println("当前时间：" + time);
// 创建指定时间
LocalTime specificTime = LocalTime.of(12, 30, 0);
System.out.println("指定时间：" + specificTime);
- 格式化与解析（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类的主要功能包括以下几个方面：
-
获取Calendar对象：可以使用Calendar类的静态方法getInstance()来获取一个Calendar对象，该对象使用默认的时区和语言环境。
-
设置日期和时间：可以使用set()方法来设置Calendar对象的年、月、日等字段的值。
-
获取日期和时间：可以使用get()方法来获取Calendar对象的年、月、日等字段的值。
-
日期计算：可以使用add()方法来对日期进行加减操作。例如，可以将日期加上一天，或减去一个月。
-
日期比较：可以使用compareTo()方法来比较两个日期的先后顺序。
-
日期字段：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)); // 注意月份要加1
System.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，它提供了一系列的日期、时间和时间间隔的类，用于更方便地处理日期和时间的操作。下面是一些常用的时间工具类的简介：
- LocalDate：表示一个日期，不包含时间和时区信息。
- LocalTime：表示一个时间，不包含日期和时区信息。
- LocalDateTime：表示一个日期和时间，不包含时区信息。
- ZonedDateTime：表示一个带时区的日期和时间。
- Instant：表示一个时间戳，也就是从1970年1月1日午夜（格林威治时间）开始的秒数。
- Duration：表示一个时间段，可以用于计算两个时间点之间的间隔。
- Period：表示一个日期段，可以用于计算两个日期之间的间隔。
- DateTimeFormatter：用于格式化和解析日期和时间的类。
- 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个基本数据类型对应的包装类，分别为：
- Boolean：对应boolean类型。
- Byte：对应byte类型。
- Short：对应short类型。
- Integer：对应int类型。
- Long：对应long类型。
- Float：对应float类型。
- Double：对应double类型。
- Character：对应char类型。
包装类提供了一系列的方法和属性，用于操作和获取基本数据类型的值。它们还提供了一些静态方法，用于将字符串转换为相应的基本数据类型。
包装类的主要作用有以下几点：
- 提供了对象化的方式来处理基本数据类型，方便与其他对象进行交互。
- 在集合类中，只能存储对象，无法直接存储基本数据类型，因此可以使用包装类来包装基本数据类型，然后存储到集合中。
- 在某些情况下，需要将基本数据类型作为方法参数进行传递，但方法的参数只能是对象，此时可以使用包装类来包装基本数据类型。
使用包装类的一般步骤如下：
- 创建包装类对象，并传入基本数据类型的值。
- 使用包装类对象中的方法和属性进行操作和获取基本数据类型的值。
以下是一个示例，演示了如何使用包装类：
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); // 输出：转换结果：12345
System.out.println("转换结果：" + num2); // 输出：转换结果：-1
System.out.println("转换结果：" + num3); // 输出：转换结果：-1
System.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); // 输出：二进制表示：1010
System.out.println("二进制表示：" + binaryString2); // 输出：二进制表示：10111
System.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年是否为闰年，并输出结果。