JDK7前时间相关类:

时间的相关知识:

Data时间类:

 

//1.创建对象表示一个时间
Date d1 = new Date();
//System.out.println(d1);//2.创建对象表示一个指定的时间
Date d2 = new Date(0L);
System.out.println(d2);//3.setTime修改时间
//1000毫秒=1秒
d2.setTime(1000L);
System.out.println(d2);//4.getTime获取当前时间的毫秒值
long time = d2.getTime();
System.out.println(time);

 

SimpleDateFormat 类作用:

 

SimpleDateFormat 类:

 

//1.利用空参构造创建SimpleDateFormat对象，默认格式
SimpleDateFormat sdf1 = new SimpleDateFormat();
Date d1 = new Date(OL);
String str1 = sdf1.format(d1);
System.out.println(str1);//1970/1/1上午8:00//2.利用带参构造创建SimpleDateFormat对象，指定格式
SimpleDateFormat sdf2 = new SimpleDateFormat(pattern:"yyyy年MM月dd日 HH:mm:ss EE");
String str2 = sdf2.format(d1);
System.out.println(str2);//1970年01月e1日08:00:00//课堂练习：yyyy年MM月dd日时:分:秒星期E

//1.定义一个字符串表示时间
String str = "2023-11-11 11:11:11";//2.利用空参构造创建SimpleDateFormat对象
//细节：
//创建对象的格式要跟字符串的格式完全一致
SimpleDateFormat sdf = new SimpleDateFormat(pattern:"yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(str);//3.打印结果
System.out.println(date.getTime());//1699672271000

 Calendar概述:

 Calendar常用方法:

 细节1：Calendar是一个抽象类，不能直接new，而是通过一个静态方法获取到子类对象
 底层原理：会根据系统的不同时区来获取不同的日历对象. 把会把时间中的纪元，年，月，日，时，分，秒，星期，等等的都放到一个数组当中.

 细节2：月份：范围0~11 如果获取出来的是0.那么实际上是1月。
  星期：在老外的眼里，星期日是一周中的第一天
1（星期日)   2（星期一） 3（星期二）4（星期三）5（星期四）6（星期五）7（星期六）

 JDK8:

ZoneID时区:

//1.获取所有的时区名称
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size());//600
System.out.println(zoneIds);// Asia/Shanghai//2.获取当前系统的默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);//Asia/Shanghai//3.获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
System.out.println(zoneId1);//Asia/Pontianak

Instant时间戳:

//1.获取当前时间的Instant对象（标准时间）
//Instant now = Instant.now();
//System.out.println(now);//2.根据（秒/毫秒/纳秒）获取Instant对象
Instant instant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);//1970-01-01T00:00:00zInstant instant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);//1970-01-01T00:00:01ZInstant instant3 = Instant.ofEpochSecond(epochSecond:1L,nanoAdjustment:1eeeeeeeeeL);
System.out.println(instant3);//1970-01-01T00:00:02z//3.指定时区
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);//4.isXxx判断
Instant instant4 = Instant.ofEpochMilli(0L);
Instant instant5 = Instant.ofEpochMilli(1000L);//5.用于时间的判断
//isBefore：判断调用者代表的时间是否在参数表示时间的前面
boolean result1 = instant4.isBefore(instant5);
System.out.println(result1);//true//isAfter：判断调用者代表的时间是否在参数表示时间的后面
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);//false//6.Instant minusXxx(long millisToSubtract)减少时间系列的方法
Instant instant6 = Instant.ofEpochMilli(3000L);
System.out.println(instant6);//1970-01-01T00:00:03Z
Instant instant7 = instant6.minusSeconds(1);
System.out.println(instant7);//1970-01-01T00:00:02z

ZoneDateTime带时区的时间:

//1.获取当前时间对象（带时区）
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);//2.获取指定的时间对象（带时区）
//年月日时分秒纳秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(year:2023, month: 10, dayOfMonth:1,
hour: 11,minute:12, second: 12, nanoOfSecond: 0 ,ZoneId.of("Asia/Shanghai");
System.out.println(time1);//通过Instant+时区的方式指定获取时间对象
Instant instant = Instant.ofEpochMilli(OL);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);//3.withXxx修改时间系列的方法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);//4.减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);//5.增加时间
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);

  细节：JDK8新增的时间对象都是不可变的.  如果我们修改了，减少了，增加了时间.  那么调用者是不会发生改变的，产生一个新的时间.

DateTimeFormatter用于时间的格式化和解析:

//获取时间对象
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
//解析/格式化器
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EE a");
//格式化
System.out.println(dtf1.format(time));

LocalDate、LocalTime、LocalDateTime:

//1.获取当前时间的日历对象（包含年月日）
LocalDate nowDate = LocalDate.now();
System.out.println("今天的日期:"+nowDate);//2.获取指定的时间的日历对象
LocalDate 1dDate = LocalDate.of(year: 2023,month:1,dayOfMonth:1);
System.out.println("指定日期:"+1dDate);
System.out.println("=========");//3.get系列方法获取日历中的每一个属性值
//获取年
int year = ldDate.getYear();
System.out.println("year: " + year);//获取月
//方式一：
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());
//方式二：
int month = ldDate.getMonthValue();
System.out.println("month: " + month);//获取日
int day = 1dDate.getDayOfMonth();
System.out.println("day: " + day);//获取一年的第几天
int dayOfYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayOfYear);///获取星期
DayOfWeek dayOfWeek = 1dDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());//is开头的方法表示判断
System.out.println(ldDate.isBefore(1dDate));
System.out.println(1dDate.isAfter(ldDate));//with开头的方法表示修改，只能修改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);//minus开头的方法表示减少，只能减少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);//plus开头的方法表示增加，只能增加年月日
LocalDate plusLocalDate = 1dDate.plusDays(1);
System.out.println(plusLocalDate);

Duration、Period、ChronoUnit:

//当前本地年月日
LocalDate today = LocalDate.now();
System.out.println(today);//生日的年月日
LocalDate birthDate = LocalDate.of(year:2000,month:1,dayOfMonth:1);
System.out.println(birthDate);
Periodperiod=Period.between(birthDate,today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:"+ period);//P22Y6M17D
System.out.println(period.getYears());
System.out.println(period.getMonths()); 
System.out.println(period.getDays());
System.out.println(period.toTotalMonths());

//本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);//出生的日期时间对象
LocalDateTime birthDate= LocalDateTime.of(year:2000,month:1,dayOfMonth:1,hour:0, minute:00,second:00);
System.out.println(birthDate);
Duration duratior = Duration.between(birthDate，today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + duration);System.out.println(duration.toDays());//两个时间差的天数
System.out.println(duration.toHours());//两个时间差的小时数
System.out.println(duration.toMinutes());//两个时间差的分钟数
System.out.println(duration.toMillis());//两个时间差的毫秒数
System.out.println(duration.toNanos());//两个时间差的纳秒数

//当前时间
LocalDateTime tōday = LocalDateTime.now();
System.out.println(today);//生日时间
LocalDateTime birthDate = LocalDateTime.of(year:2eee,month:1,dayOfMonth:1,
hour: 0,minute:0,second: 0);
System.out.println(birthDate);System.out.printIn("相差的年数:"+ ChronoUnit.YEARS.between(birthDate,today));
System.out.printIn("相差的月数: "+ ChronoUnit.MONTHS.between(birthDate,today));
System.out.printIn("相差的周数: "+ ChronoUnit.WEEKS.between(birthDate,today));
System.out.println("相差的天数: "+ ChronoUnit.DAYs.between(birthDate,today));
System.out.println("相差的时数:"+ ChronoUnit.HOuRs.between(birthDate,today));
System.out.printIn("相差的分数:"+ ChronoUnit.MINUTES.between(birthDate,today));
System.out.println("相差的秒数: "+ ChronoUnit.SECoNDS.between(birthDate,today));
System.out.printIn("相差的毫秒数:"+ ChronoUnit.MILLIS.between(birthDate,today));
System.out.printIn("相差的微秒数: "+ ChronoUnit.MICRos.between(birthDate,today));
System.out.println("相差的纳秒数:"+ ChronoUnit.NANOs.between(birthDate,today));
System.out.println("相差的半天数: "+ ChronoUnit.HALF_DAYS.between(birthDate,today));
System.out.println("相差的十年数:"+ ChronoUnit.DECADES.between(birthDate,today));
System.out.println("相差的世纪(百年)数:"+ChronoUnit.CENTURIES.between(birthDate,today));
System.out.println("相差的千年数:"+ ChronoUnit.MILLENNIA.between(birthDate,today));
System.out.println("相差的纪元数: "+ ChronoUnit.ERAS.between(birthDate,today));

包装类:

//1.利用构造方法获取Integer的对象（JDK5以前的方式）
Integer i1 =r
new Integer(value:1);
Integer i2 = new Integer(s:"1");
System.out.println(i1);
System.out.println(i2);//2.利用静态方法获取Integer的对象（JDK5以前的方式）
Integer i3 = Integer.valueOf(123);
Integer i4 = Integer.valueOf("123");
Integer i5 = Integer.valueOf(s:"123",radix:8);System.out.println(i3);
System.out.println(i4);
System.out.println(i5);//83

//3.这两种方式获取对象的区别（掌握）
Integer i6 =Integer.valueOf(127);
Integer i7 =Integer.valueOf(127);
System.out.println(i6==i7);//falseInteger i8 = Integer.valueOf(128)
Integer i9 = Integer.valueof(128);
System.out.println(i8==i9);Integer i10 = new Integer(value:127);
Integer i11 = new Integer(value:127);
System.out.println(i10==i11);Integer i12 = new Integer(value:128)
Integer i13 = new Integer(value:128);
System.out.println(i12==i13);

  底层原理：因为在实际开发中，-128~127之间的数据，用的比较多.  如果每次使用都是new对象，那么太浪费内存了.  所以，提前把这个范围之内的每一个数据都创建好对象.  如果要用到了不会创建新的，而是返回已经创建好的对象.

//1.把整数转成二进制，十六进制
String str1 = Integer.toBinaryString(i:100);
System.out.println(str1);//1100100//2.把整数转成八进制
String str2 = Integer.toOctalString(i:100);
System.out.println(str2);//144//3.把整数转成十六进制
String str3 = Integer.toHexString(i:100);
System.out.println(str3);//64//4.将字符串类型的整数转成int类型的整数
//强类型语言：每种数据在java中都有各自的数据类型
//在计算的时候，如果不是同一种数据类型，是无法直接计算的。
int i = Integer.parseInt(s:"123");
System.out.println(i);
System.out.println(i + 1);//124

 细节1：在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
 细节2：8种包装类当中，除了character都有对应的parseXxx的方法，进行类型转换

//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
System.out.println(str);String line = sc.nextLine();
System.out.println(line);double V = Double.parseDouble(1ine);
System.out.println(v + 1);

 弊端：当我们在使用next，nextInt，nextDouble在接收数据的时候，遇到空格，回车，制表符的时候就停止了 ,键盘录入的是123123那么此时只能接收到空格前面的数据 , 我想要的是接收一整行数据.
 约定：以后我们如果想要键盘录入，不管什么类型，统一使用nextLine , 特点遇到回车才停止.

Arrays:

//toString：将数组变成字符串
int[] arr = {1,2, 3, 4, 5,6, 7,8,9,10};
System.out.println(Arrays.toString(arr));//[1,2,3,4,5,6,7,8,9,10]//binarySearch:二分查找法查找元素
//细节1：二分查找的前提：数组中的元素必须是有序，数组中的元素必须是升序的
//细节2：如果要查找的元素是存在的，那么返回的是真实的索引
//但是，如果要查找的元素是不存在的，返回的是插入点-1
//疑问：为什么要减1呢？
//解释：如果此时，我现在要查找数字0，那么如果返回的值是-插入点，就会出现问题了。
//如果要查找数字0，此时θ是不存在的，但是按照上面的规则-插入点，应该就是-0
//为了避免这样的情况，Java在这个基础上又减一。
System.out.println(Arrays.binarySearch(arr,key:10));//9
System.out.println(Arrays.binarySearch(arr,key:2));//1
System.out.printIn(Arrays.binarySearch(arr,key:20));//-11//copyof:拷贝数组
//参数一：老数组
//参数二：新数组的长度
//方法的底层会根据第二个参数来创建新的数组
//如果新数组的长度是小于老数组的长度，会部分拷贝
//如果新数组的长度是等于老数组的长度，会完全拷贝
//如果新数组的长度是大于老数组的长度，会补上默认初始值
int[] newArr1 = Arrays.copyof(arr,newLength:20);
System.out.println(Arrays.toString(newArr1));//[1,2, 3,4, 5,6, 7,8, 9,10]//copyOfRange:拷贝数组（指定范围）
//细节：包头不包尾，包左不包右
int[] newArr2 = Arrays.copyOfRange(arr，from:0,to:9);
System.out.println(Arrays.toString(newArr2));//[1,2,3,4,5,6,7,8,9]//fi1l:填充数组
Arrays.fill(arr,val:100);
System.out.println(Arrays.toString(arr));//sort：排序。默认情况下，给基本数据类型进行升序排列。底层使用的是快速排序。
int[] arr2 = {10, 2, 3, 5,6,1,7,8, 4,9};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));

  底层原理：利用插入排序+二分查找的方式进行排序的。默认把θ索引的数据当做是有序的序列，1索引到最后认为是无序的序列。遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素  把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
  如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
  如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
  如果方法的返回值悬0，也拿着A跟后面的数据进行比较
  直到能确定A的最终位置为止。