以下学习笔记记录于:2024.09.04-2024.09.10
阶段二 JavaSE进阶
第二章 常用API
2-2 时间日期类
53 传统时间:Date日期类
DateTest.java:
import java.util.Date;
// 目标:掌握Date日期类的使用
public class DateTest {
public static void main(String[] args) {
// 1、创建一个Date的对象,代表系统当前时间信息的
Date d = new Date();
System.out.println(d);
// 2、拿到时间毫秒值
long time = d.getTime();
System.out.println(time);
// 3、把时间毫秒值转换成日期对象:2s之后的时间是多少。(此处time为毫秒单位)
time += 2 * 1000;
Date d2 = new Date(time);
System.out.println(d2);
// 4、直接把日期对象的时间通过setTime方法进行修改
Date d3 = new Date();
d3.setTime(time);
System.out.println(d3);
}
}
运行结果:
54 传统时间:SimpleDateFormat日期格式化
SimpleDateFormatTest.java:
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatTest {
public static void main(String[] args) throws ParseException {
// 1、准备一些时间
Date d = new Date();
System.out.println(d);
long time = d.getTime();
System.out.println(time); // 毫秒值
// 2、格式化日期对象,和时间(毫秒值)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a");
String rs = sdf.format(d);
String rs2 = sdf.format(time);
System.out.println(rs);
System.out.println(rs2);
System.out.println("---------------------------------");
// 目标:掌握SimpleDateFormat解析字符串时间成为日期对象
String dateStr = "2022-12-12 12:12:11";
// 1、创建简单日期格式化对象,指定的时间格式必须与被解析的时间格式一模一样,否则程序会出bug
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d2 = sdf2.parse(dateStr);
System.out.println(d2);
}
}
运行结果:
55 传统时间:秒杀案例
miaoshaTest.java:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class miaoshaTest {
public static void main(String[] args) throws ParseException {
// 1、把开始时间、结束时间、小贾下单时间、小皮下单时间拿到程序中来
String start = "2023年11月11日 0:0:0";
String end = "2023年11月11日 0:10:0";
String xj = "2023年11月11日 0:01:18";
String xp = "2023年11月11日 0:10:57";
// 2、把字符串的时间解析成日期对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date startDt = sdf.parse(start);
Date endDt = sdf.parse(end);
Date xjDt = sdf.parse(xj);
Date xpDt = sdf.parse(xp);
// 3、开始判断小皮和小贾是否秒杀成功
// 把日期对象转换成时间毫秒值来判断
long startTime = startDt.getTime();
long endTime = endDt.getTime();
long xjTime = xjDt.getTime();
long xpTime = xpDt.getTime();
if (xjTime >= startTime && xjTime <= endTime){
System.out.println("小贾您秒杀成功了!!!");
}else {
System.out.println("小贾您秒杀失败");
}
if (xpTime >= startTime && xpTime <= endTime){
System.out.println("小皮您秒杀成功了!!!");
}else {
System.out.println("小皮您秒杀失败");
}
}
}
运行结果:
56 传统时间:Calendar
原本的解决方式:
CalendarTest.java:
import java.util.Calendar;
import java.util.Date;
public class CalendarTest {
public static void main(String[] args) {
// 1、得到系统此刻时间对应的日历对象
Calendar now = Calendar.getInstance();
System.out.println(now);
// 2、获取日历中的某个信息
int year = now.get(Calendar.YEAR);
System.out.println(year);
int days = now.get(Calendar.DAY_OF_YEAR);
System.out.println(days);
// 3、拿到日历中记录的日期对象
Date d = now.getTime();
System.out.println(d);
// 4、拿到当前时间毫秒值
long time = now.getTimeInMillis();
System.out.println(time);
// 5、修改日历中的某个信息
now.set(Calendar.MONTH, 9); // 此处是从0开始算的,所以9表示10月份
now.set(Calendar.DAY_OF_YEAR, 125); // 修改成一年中的第125天
System.out.println(now);
// 6、为某个信息增加或者减少多少
now.add(Calendar.DAY_OF_YEAR, 100);
now.add(Calendar.DAY_OF_YEAR, -10);
System.out.println(now);
}
}
57 为什么要学习JDK8新增的时间
JDK8新增的时间如下:
2-3 JDK8新时间
58 LocalDate、LocalTime、LocalDateTime
1) LocalDate
LocalDateTest.java:
import java.time.LocalDate;
public class LocalDateTest {
public static void main(String[] args) {
// 获取本地日期对象(不可变的)
LocalDate ld = LocalDate.now(); // 年 月 日 星期 (不可变的)
System.out.println(ld);
// 1、获取日期对象中的信息
int year = ld.getYear(); // 年
int month = ld.getMonthValue(); // 月
int day = ld.getDayOfMonth(); // 日
int dayOfyear = ld.getDayOfYear(); // 一年中的第几天
int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几
System.out.println(year);
System.out.println(day);
System.out.println(dayOfWeek);
System.out.println("----------------------");
// 2、直接修改某个信息(返回一个新对象,保持原对象):withYear、withMonth、withDayOfMonth、withDayOfYear
LocalDate ld2 = ld.withYear(2099);
LocalDate ld3 = ld.withMonth(12);
System.out.println(ld);
System.out.println(ld2);
System.out.println(ld3);
// 3、把某个信息加多少(返回一个新对象,保持原对象):plusYears、plusMonths、plusDays、plusWeeks
LocalDate ld4 = ld.plusYears(2);
LocalDate ld5 = ld.plusMonths(2);
// 4、把某个信息减多少:minusYears、minusMonths、minusDays、minusWeeks
LocalDate ld6 = ld.minusMonths(2);
LocalDate ld7 = ld.minusYears(2);
// 5、获取指定日期的LocalDate对象:public static LocalDate of( int year, int month, int dayOfMonth)
LocalDate ld8 = LocalDate.of(2099, 12,12);
LocalDate ld9 = LocalDate.of(2099, 12,12);
System.out.println("----------------------");
// 6、判断2个日期对象,是否相等、是前还是在后:equals、isBefore、isAfter
System.out.println(ld8.equals(ld9)); // true
System.out.println(ld8.isBefore(ld)); // false
System.out.println(ld8.isAfter(ld)); // true
}
}
运行结果:
2) LocalTime
LocalTimeTest.java:
import java.time.LocalTime;
public class LocalTimeTest {
public static void main(String[] args) {
// 获取本地时间对象(不可变的)
LocalTime lt = LocalTime.now(); //时 分 秒 纳秒 (不可变的)
System.out.println(lt);
// 1、获取时间中的信息
int hour = lt.getHour(); //时
int minute = lt.getMinute(); //分
int second = lt.getSecond(); //秒
int nano = lt.getNano(); //纳秒
System.out.println(hour);
// 2、修改时间:withHour、withMinute、withSecond、withNano
LocalTime lt3 = lt.withHour(10);
LocalTime lt4 = lt.withMinute(10);
LocalTime lt5 = lt.withSecond(10);
LocalTime lt6 = lt.withNano(10);
System.out.println(lt3);
// 3、加多少:plusHours、plusMinutes、plusSeconds、plusNanos
LocalTime lt7 = lt.plusHours(10);
LocalTime lt8 = lt.plusMinutes(10);
LocalTime lt9 = lt.plusSeconds(10);
LocalTime lt10 = lt.plusNanos(10);
System.out.println(lt7);
// 4、减多少:minusHours、minusMinutes、minusSeconds、minusNanos
LocalTime lt11 = lt.minusHours(10);
LocalTime lt12 = lt.minusMinutes(10);
LocalTime lt13 = lt.minusSeconds(10);
LocalTime lt14 = lt.minusNanos(10);
System.out.println(lt11);
// 5、获取指定时间的LocalTime对象: public static LocalTime of(int hour, int minute, int second)
LocalTime lt15 = LocalTime.of(12,12, 12);
LocalTime lt16 = LocalTime.of(12,12,12);
System.out.println("---------------------");
// 6、判断2个时间对象,是否相等、在前还是在后:equals isBefore isAfter
System.out.println(lt15.equals(lt16));
System.out.println(lt15.isAfter(lt));
System.out.println(lt15.isBefore(lt));
}
}
运行结果:
3) LocalDateTime
LocalDateTimeTest.java:
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class LocalDateTimeTest {
// 获取本地日期和时间对象。
LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒 纳秒
// 可以把LocalDateTime转换成LocalDate和LocalTime
// public LocalDate toLocalDate()
// public LocalTime toLocalTime()
// public static LocalDateTime of(LocalDate date, LocalTime time)
LocalDate ld = ldt.toLocalDate();
LocalTime lt = ldt.toLocalTime();
LocalDateTime ldt10 = LocalDateTime.of(ld, lt);
}
59 ZoneId、ZonedDateTime
ZoneId_ZonedDateTime_Test.java:
import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;
// 目标:了解时区和带时区的时间
public class ZoneId_ZonedDateTime_Test {
public static void main(String[] args) {
// 1、ZoneId的常见方法:
// public static ZoneId systemDefault(): 获取系统默认的时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId.getId());
// System.out.println(zoneId.toString());
System.out.println(zoneId);
// public static Set<String> getAvailableZoneIds():获取Java支持的全部时区Id
System.out.println(ZoneId.getAvailableZoneIds());
// public static Zoneld of(String zoneId):把某个时区id封装成ZoneId对象。
ZoneId zoneId1 = ZoneId.of("America/New_York");
// 2、ZonedDateTime:带时区的时间。
// public static ZonedDateTime now(ZoneId zone):获取某个时区的ZonedDateTime对象。
ZonedDateTime now = ZonedDateTime.now(zoneId1);
System.out.println(now);
// 世界标准时间
ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
System.out.println(now1);
// public static ZonedDateTime now():获取系统默认时区的ZonedDateTime对象
ZonedDateTime now2 = ZonedDateTime.now();System.out.println(now2);
}
}
运行结果:
60 Instant
InstantTest.java:
import java.time.Duration;
import java.time.Instant;
public class InstantTest {
public static void main(String[] args) {
// 1、创建Instant对象,获取此刻时间信息(总秒数 不到1秒的纳秒数)
Instant now = Instant.now(); // 不可变对象
// 2、获取总秒数
long second = now.getEpochSecond();
System.out.println(second);
// 3、获取不够1秒的纳秒数
int nano = now.getNano();
System.out.println(nano);
// 判断系列、减少时间系列、增加时间系列的方法使用方式均与之前所学过的LocalDate等一致
Instant instant = now.plusNanos(10);
System.out.println(instant);
// Instant对象的作用:做代码的性能分析、或者记录用户的操作时间点
Instant start = Instant.now();
// 其他代码执行。。。。。。
for (int i = 0; i < 100000; i++) {} // 代码1
Instant end = Instant.now();
Duration timeElapsed = Duration.between(start, end);
System.out.println("运行时间: " + timeElapsed.toNanos() + " 纳秒"); // 输出代码1的运行时间
}
}
运行结果:
61 DateTimeFormatter
DateTimeFormatterTest.java:
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class DateTimeFormatterTest {
public static void main(String[] args) {
// 1、创建一个日期时间格式化器对象
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 2、对所给时间进行格式化
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
String rs = formatter.format(now); // 正向格式化
System.out.println(rs);
// 3、格式化时间的另一种方案
String rs2 = now.format(formatter); // 反向格式化
System.out.println(rs2);
// 4、解析时间:解析时间一般使用LocalDateTime提供的解析方法来进行解析。
String dateStr = "2029-12-12 12:12:12";
LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
System.out.println(ldt);
}
}
运行结果:
62 Period、Duration
1) Period
PeriodTest.java:
import java.time.LocalDate;
import java.time.Period;
/*
* 目标:掌握Period的作用,计算机每个日期相差的年数、月数、天数。
* */
public class PeriodTest {
public static void main(String[] args) {
LocalDate start = LocalDate.of(2029, 8, 15);
LocalDate end = LocalDate.of(2029, 9, 10);
// 1、创建Period对象,封装两个日期对象
Period period = Period.between(start, end);
// 2、通过period对象获取两个日期对象相差的信息
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
}
}
运行结果:
2) Duration
DurationTest.java:
import java.time.Duration;
import java.time.LocalDateTime;
public class DurationTest {
public static void main(String[] args) {
LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);
// 1、得到Duration对象
Duration duration = Duration.between(start, end);
// 2、获取两个时间对象间隔的信息
System.out.println(duration.toDays());
System.out.println(duration.toHours());
System.out.println(duration.toMinutes());
System.out.println(duration.toSeconds());
System.out.println(duration.toMillis()); // 间隔多少毫秒
System.out.println(duration.toNanos()); // 间隔多少纳秒
}
}
运行结果:
2-4 Arrays类
63 基本使用
ArraysTest1.java:
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.function.IntToDoubleFunction;
public class ArraysTest1 {
public static void main(String[] args) {
// 1、public static string tostring(类型[] arr):返回数组的内容
int[]arr = {10, 20, 30, 40, 50, 60};
System.out.println(Arrays.toString(arr));
// 2、public static 类型[] copyOfRange(类型[] arr,起始索引,结束索引):拷贝数组(指定范围,[…,…)包前不包后)
int[] arr2 = Arrays.copyOfRange(arr,1,4);
System.out.println(Arrays.toString(arr2));
// 3、public static copyOf(类型[] arr,int newLength):拷贝数组,可以指定新数组的长度。
int[] arr3 =Arrays.copyOf(arr,10);
System.out.println(Arrays.toString(arr3));
// 4、public static setAll(double[] array,IntToDoubleFunction generator):把数组中的原教数据改为新数据义存进去
double[] prices ={99.8, 128, 100};
// 把所有的价格都打八折,然后又存进去
Arrays.setAll(prices, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
BigDecimal p = BigDecimal.valueOf(prices[value]);
double a = 0.8;
BigDecimal p1 = p.multiply(BigDecimal.valueOf(a));
return p1.doubleValue();
// return prices[value] * 0.8; // 可以选择用BigDecimal计算(此处不会失真可直接return)
}
});
System.out.println(Arrays.toString(prices));
// 5、public static void sort(类型[] arr):对数组进行排序(默认是升序排序)。若数组中存储的是对象则需要自定义排序规则。
Arrays.sort(prices);
System.out.println(Arrays.toString(prices));
}
}
运行结果:
64 自定义排序规则的方式一
Student.java:
public class Student implements Comparable<Student>{
private String name;
private double height;
private int age;
// 指定比较规则
@Override
public int compareTo(Student o) {
// 约定1:认为左边对象 大于 右边对象,请您返回正整数
// 约定2:认为左边对象 小于 右边对象,请您返回负整数
// 约定3:认为左边对象 等于 右边对象,请您一定返回0
// 按照年龄升序排序(此处要求返回int,而年龄数据类型刚好为int,则可以直接用加减法进行return)。
// if (this.age > o.age){
// return 1;
// }else if (this.age < o.age){
// return -1;
// }
// return 0;
return this.age - o.age; // 升序
// return o.age - this.age; // 降序
}
public Student() {
}
public Student(String name, double height, int age) {
this.name = name;
this.height = height;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", height=" + height +
", age=" + age +
'}';
}
}
ArraysTest2.java:
import java.util.Arrays;
// 目标:掌握如何对数组中的对象进行排序
public class ArraysTest2 {
public static void main(String[] args) {
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精",169.6, 890);
students[1] = new Student("紫霞",165.5, 18);
students[2] = new Student("至尊宝",183.0, 1000);
students[3] = new Student("兔精",158.9, 248);
// 1、public static void sort(类型[] arr): 对数组进行排序
Arrays.sort(students);
for (int i = 0; i < students.length; i++) {
System.out.println(students[i]);
}
// for (Student student : students) {
// System.out.println(student);
// }
}
}
运行结果:
65 自定义排序规则的方式二
Student.java无改动,ArraysTest2.java改动如下:
import java.util.Arrays;
import java.util.Comparator;
// 目标:掌握如何对数组中的对象进行排序
public class ArraysTest2 {
public static void main(String[] args) {
……
// 1、public static void sort(类型[] arr): 对数组进行排序
……
// 2、public static <T> void sort(T[] arr,Comparator<? super T> c)
// 参数一: 需要排序的数组
// 参数二: Comparator比较器对象(用来制定对象的比较规则)
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 约定1:认为左边对象 大于 右边对象,请您返回正整数
// 约定2:认为左边对象 小于 右边对象,请您返回负整数
// 约定3:认为左边对象 等于 右边对象,请您一定返回0
// 按照身高升序排序(此处要求返回int,而身高数据类型为double,则不可以直接用加减法进行return,只能老老实实用if语句判断大小)。
// if (o1.getHeight() > o2.getHeight()){
// return 1;
// }else if (o1.getHeight() < o2.getHeight()){
// return -1;
// }
// return 0; // 升序
return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
// return Double.compare(o2.getHeight(), o1.getHeight()); // 降序
}
});
}
}
运行结果: