目录
1.LocalDate
// 0、获取本地日期对象(不可变对象)
LocalDate ld = LocalDate.now(); // 年 月 日
System.out.println(ld);
// 1、获取日期对象中的信息
int year = ld.getYear(); // 年
int month = ld.getMonthValue(); // 月(1-12)
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);
// 2、直接修改某个信息: withYear、withMonth、withDayOfMonth、withDayOfYear
LocalDate ld2 = ld.withYear(2099);
LocalDate ld3 = ld.withMonth(12);
System.out.println(ld2);
System.out.println(ld3);
System.out.println(ld); //不变
// 3、把某个信息加多少: plusYears、plusMonths、plusDays、plusWeeks
LocalDate ld4 = ld.plusYears(2);
LocalDate ld5 = ld.plusMonths(2);
// 4、把某个信息减多少:minusYears、minusMonths、minusDays、minusWeeks
LocalDate ld6 = ld.minusYears(2);
LocalDate ld7 = ld.minusMonths(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);
// 6、判断2个日期对象,是否相等,在前还是在后: equals isBefore isAfter
System.out.println(ld8.equals(ld9));// true
System.out.println(ld8.isAfter(ld)); // true
System.out.println(ld8.isBefore(ld)); // false
2.LocalTime
记录 时,分,秒,纳秒 不可变的
Nano 纳秒
3.LocalDateTime
记录 年,月,日,时,分,秒,纳秒
// 7、可以把LocalDateTime转换成LocalDate和LocalTime
LocalDate ld=ldt.toLocalDate();
LocalTime lt=ldt.toLocalTime();
LocalDateTime ldt1=LocalDateTime.of(ld,lt);
4.美国时间 ZoneId:时区id
zonedDateTime:带时区的时间
// 目标:了解时区和带时区的时间。
// 1、ZoneId的常见方法:
// public static ZoneId systemDefault(): 获取系统默认的时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId.getId());
System.out.println(zoneId);
// public static Set<String> getAvailableZoneIds(): 获取Java支持的全部时区Id
System.out.println(ZoneId.getAvailableZoneIds());
// public static ZoneId 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);
// Calendar instance = Calendar.getInstance(TimeZone.getTimeZone(zoneId1));
Instant:时间线上的某个时刻/时间戳
通过获取Instant的对象可以拿到此刻的时间,该时间由两部分组成:从1970-01-01 00:00:00 开始走到此刻的总秒数 + 不够1秒的纳秒
// 1、创建Instant的对象,获取此刻时间信息
Instant now = Instant.now(); // 不可变对象
// 2、获取总秒数
long second = now.getEpochSecond();
System.out.println(second);
// 3、不够1秒的纳秒数
int nano = now.getNano();
System.out.println(nano);
System.out.println(now);
Instant instant = now.plusNanos(111);
// Instant对象的作用:做代码的性能分析,或者记录用户的操作时间点
Instant now1 = Instant.now();
// 代码执行。。。。
Instant now2 = Instant.now();
LocalDateTime l = LocalDateTime.now();
作用:可以用来记录代码的执行时间,或用于记录用户操作某个事件的时间点。
DateTimeFormatter
格式化器,用于时间的格式化、解析
ofPattern 获取格式化对象
format(时间对象)格式化时间
LocalDateTime提供的格式化,解析时间的方法:
format(DateTimeFormatter formatter) 格式化时间
parse 解析时间
/**
* 目标:掌握JDK 8新增的DateTimeFormatter格式化器的用法。
*/
public class Test6_DateTimeFormatter {
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:11";
LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
System.out.println(ldt);
}
}
Period:计算日期间隔(年,月,日)
可以用于计算两个 LocalDate对象 相差的年数、月数 、天
LocalDate start = LocalDate.of(2029, 8, 10);
LocalDate end = LocalDate.of(2029, 12, 15);
// 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());
}
}
Duration:计算时间间隔(时,分,秒,纳秒)
可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数;支持LocalTime、LocalDateTime、Instant等时间
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());// 间隔多少纳秒
Arrays
用来操作数组的一个工具类。
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};
// 0 1 2
// 把所有的价格都打八折,然后又存进去。
Arrays.setAll(prices, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
// value = 0 1 2
return prices[value] * 0.8;
}
});
System.out.println(Arrays.toString(prices));
// 5、public static void sort(类型[] arr):对数组进行排序(默认是升序排序)
Arrays.sort(prices);
System.out.println(Arrays.toString(prices));
}
}
public class Student implements Comparable<Student>{
private String name;
private double height;
private int age;
// 指定比较规则
// this o
@Override
public int compareTo(Student o) {
// 约定1:认为左边对象 大于 右边对象 请您返回正整数
// 约定2:认为左边对象 小于 右边对象 请您返回负整数
// 约定3:认为左边对象 等于 右边对象 请您一定返回0
// 按照年龄升序排序。
// 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; // 降序
}
// 目标:掌握如何对数组中的对象进行排序。
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精", 169.5, 23);
students[1] = new Student("紫霞", 163.8, 26);
students[2] = new Student("紫霞", 163.8, 26);
students[3] = new Student("至尊宝", 167.5, 24);
// 1、public static void sort(类型[] arr):对数组进行排序。
// Arrays.sort(students);
// System.out.println(Arrays.toString(students));
// 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) {
// 制定比较规则了:左边对象 o1 右边对象 o2
// 约定1:认为左边对象 大于 右边对象 请您返回正整数
// 约定2:认为左边对象 小于 右边对象 请您返回负整数
// 约定3:认为左边对象 等于 右边对象 请您一定返回0
// 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()); // 降序
}
});
System.out.println(Arrays.toString(students));
Lambda表达式
作用:用于简化匿名内部类的代码写法。
Swimming s=(被重写方法的形参列表) -> {
被重写方法的方法体代码。
};
注意:Lambda表达式并不是说能简化全部匿名内部类的写法,只能简化函数式接口的匿名内部类。
函数式接口:
有且仅有一个抽象方法的接口。
注意:将来我们见到的大部分函数式接口,上面都可能会有一个@FunctionalInterface的注解,有该注解的接口就必定是函数式接口。
// Arrays.setAll(prices, (int value) -> {
// return prices[value] * 0.8;
// });
// Arrays.setAll(prices, (value) -> {
// return prices[value] * 0.8;
// });
// Arrays.setAll(prices, value -> {
// return prices[value] * 0.8;
// });
Arrays.setAll(prices, value -> prices[value] * 0.8 );
// Arrays.sort(students, new Comparator<Student>() {
// @Override
// public int compare(Student o1, Student o2) {
// return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
// }
// });
// Arrays.sort(students, (Student o1, Student o2) -> {
// return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
// });
// Arrays.sort(students, ( o1, o2) -> {
// return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
// });
Arrays.sort(students, ( o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
Lambda表达式的省略写法(进一步简化Lambda表达式的写法):
参数类型可以省略不写。
如果只有一个参数,参数类型可以省略,同时()也可以省略。
如果Lambda表达式中的方法体代码只有一行代码,可以省略大括号不写,同时要省略分号!此时,如果这行代码是return语句,也必须去掉return不写。
方法引用(标志性符号::)
静态方法的引用
类名::静态方法
如果某个Lambda表达式里只是调用一个静态方法,并且前后参数的形式一致,就可以使用静态方法引用。
实例方法的引用
对象名::实例方法。
如果某个Lambda表达式里只是调用一个实例方法,并且前后参数的形式一致,就可以使用实例方法引用
public class CompareByData {
public static int compareByAge(Student o1, Student o2){
return o1.getAge() - o2.getAge(); // 升序排序的规则
}
public int compareByAgeDesc(Student o1, Student o2){
return o2.getAge() - o1.getAge(); // 降序排序的规则
}
}
public class Test1 {
public static void main(String[] args) {
Student[] students = new Student[4];
students[0] = new Student("蜘蛛精", 169.5, 23);
students[1] = new Student("紫霞", 163.8, 26);
students[2] = new Student("紫霞", 163.8, 26);
students[3] = new Student("至尊宝", 167.5, 24);
// 原始写法:对数组中的学生对象,按照年龄升序排序
// Arrays.sort(students, new Comparator<Student>() {
// @Override
// public int compare(Student o1, Student o2) {
// return o1.getAge() - o2.getAge(); // 按照年龄升序排序
// }
// });
// 使用Lambda简化后的形式
// Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
// Arrays.sort(students, (o1, o2) -> CompareByData.compareByAge(o1, o2));
// 静态方法引用
// Arrays.sort(students, CompareByData::compareByAge);
System.out.println("--------------------------------------------------------------");
// Arrays.sort(students, (o1, o2) -> o2.getAge() - o1.getAge()); // 降序
CompareByData compare = new CompareByData();
// Arrays.sort(students, (o1, o2) -> compare.compareByAgeDesc(o1, o2)); // 降序
// 实例方法引用
Arrays.sort(students, compare::compareByAgeDesc); // 降序
System.out.println(Arrays.toString(students));
}
}
特定类型方法的引用
类型::方法。
如果某个Lambda表达式里只是调用一个实例方法,并且前面参数列表中的第一个参数是作为方法的主调,后面的所有参数都是作为该实例方法的入参的,则此时就可以使用特定类型的方法引用。
public class Test2 {
public static void main(String[] args) {
String[] names = {"boby", "angela", "Andy" ,"dlei", "caocao", "Babo", "jack", "Cici"};
// 进行排序(默认是按照字符串的首字符编号进行升序排序的)
// Arrays.sort(names);
// 要求忽略首字符大小写进行排序。
// Arrays.sort(names, new Comparator<String>() {
// @Override
// public int compare(String o1, String o2) {
// // 制定比较规则。o1 = "Andy" o2 = "angela"
// return o1.compareToIgnoreCase(o2);
// }
// });
// Arrays.sort(names, ( o1, o2) -> o1.compareToIgnoreCase(o2) );
// 特定类型的方法引用!
Arrays.sort(names, String::compareToIgnoreCase);
System.out.println(Arrays.toString(names));
}
}
构造器的引用
类名::new。
如果某个Lambda表达式里只是在创建对象,并且前后参数情况一致,就可以使用构造器引用。
public class Test3 {
public static void main(String[] args) {
// 1、创建这个接口的匿名内部类对象。
// CreateCar cc = new CreateCar(){
// @Override
// public Car create(String name, double price) {
// return new Car(name, price);
// }
// };
// CreateCar cc = ( name, price) -> new Car(name, price);
// 构造器引用
CreateCar cc = Car::new;
Car c = cc.create("奔驰", 49.9);
System.out.println(c);
}
}
interface CreateCar{
Car create(String name, double price);
}