java2_day02常用类之日期时间API等

Java常用类之日期时间API

目录

1. 字符串String相关的类

2. JDK8之前的日期时间API

3. JDK8中新日期时间API

4. java比较器

5. System类

6. Math类

7. BigInteger与BigDecimal

1 JDK8之前日期时间API

1.1 java.lang.System类

• System类提供的public static long currentTimeMilis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

 package com.xue.java;
 ​
 import org.junit.Test;
 ​
 import java.sql.SQLOutput;
 import java.util.Date;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/5
  * Time: 21:36
  * Description: JDK8 之前日期和时间的API
  */
 public class DateTimeTest {
     @Test
     public void test1(){
         //1. System类中的currentTimeMillis()
         long time = System.currentTimeMillis();
         //以毫秒为单位，1649165931382
         //称为时间戳
         System.out.println(time);
 ​
     }
 }

1.2 java.util.Date类

 /*
     java.util.Date类（父）
           |---java.sql.Date类（子）
     1. 两个构造器的使用
     2. 两个方法的使用
          >toString(): 显示当前的年、月、日、时、分、秒
          >getTime(): 获取当前Date对象对应的毫秒数（时间戳）
     3. Java。sql.Date对应着数据库中的日期类型的变量
        >如何实例化
        >如何将java.util.Date对象转换为Java。sql.Date对象
      */
     @Test
     public void test2(){
         //构造器一： Date() ：创建一个对应当前时间的Date对象
         Date date1 = new Date();
         System.out.println(date1.toString()); //Tue Apr 05 21:47:43 CST 2022
 ​
         System.out.println(date1.getTime());  //1649166463644
        //构造器二：创建指定毫秒数的Date对象
         Date date2 = new Date(1649166463656L);
         System.out.println(date2.toString());
 ​
         //创建java.util.Date对象
         java.sql.Date date3 = new java.sql.Date(1649166463644L);
         System.out.println(date3);   //2022-04-05
 ​
         //如何将java.util.Date对象转换为java.sql.Date对象
         //情况一：
         Date date4 = new java.sql.Date(1649155263644L); //多态
         java.sql.Date date5 = (java.sql.Date) date4;   //强转
         //情况二：
         Date date6 = new Date();
         java.sql.Date date7 = new java.sql.Date(date6.getTime());  //把父类的毫秒数拿来作为参数，重新new，实现转换
     }

字符串复习：视频471、472

问题1：

问题2：如何理解String类的不可变性

• String指向的字符串不可更改，修改，拼接都不行，只能新建

问题3：String类不可被继承，用final定义的

问题4：String常用方法

算法：视频473-476

---

1.3 SimpleDateFormat类

 package com.xue.java1;
 ​
 import org.junit.Test;
 ​
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/6
  * Time: 11:11
  * Description:JDK8之前的日期时间API测试
  * 1. System类中的currentTimeMillis();
  * 2. java.util.Date和子类java.sql.Date
  * 3. SimpleDateFormat
  * 4. Calendar
  */
 public class DateTimeTest {
     /*
     SimpleDateFormat的使用： SimpleDateFormat对日期Date类的格式化和解析
     1. 两个操作
        >格式化： 日期 --->字符串
        >解析： 字符串 --->日期
     2. SimpleDateFormat的实例化
      */
 ​
     @Test
     public void testSimpleDateFormat() throws ParseException {
         //实例化SimpleDateFormat： 使用默认的构造器，格式固定
         SimpleDateFormat sdf = new SimpleDateFormat();
         //格式化： 日期 --->字符串
         Date date = new Date();
         System.out.println(date);  //Wed Apr 06 11:19:31 CST 2022
 ​
         String format = sdf.format(date);
         System.out.println(format); //2022/4/6 上午11:19
         //解析： 字符串 --->日期
         String str = "2019/08/09 上午11:19";  //必须是这种格式
         Date date1 = sdf.parse(str);
         System.out.println(date1);  //Fri Aug 09 11:19:00 CST 2019
 ​
         System.out.println("====================================");
         //SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");  //帮助文档
         //格式化
         SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); //自行编辑，MM表示月份，mm代表分钟，2022-04-06 11:49:20
         String format1 = sdf1.format(date);
         System.out.println(format1);
         //解析；要求字符串必须是符合SimpleDateFormat识别的格式（通过构造器参数体现）
         Date date2 = sdf1.parse("2022-04-06 11:49:20");
         System.out.println(date2);  //Wed Apr 06 11:49:20 CST 2022
     }
 ​
     /*
     练习1： 字符串"2020-08-09"转换为java.sql.Date
     练习2： "三天打鱼两天晒网"  1990-01-01   xxxx-xx-xx 打鱼？晒网？
             总天数 % 5 == 1，2，3 ：打鱼
             总天数 % 5 == 4，0 ：晒网
      */
     @Test
     public void testExer() throws ParseException {
         String birth = "2020-08-09";
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Date date = sdf.parse(birth);
         System.out.println(date);  //Sun Aug 09 00:00:00 CST 2020
 ​
         java.sql.Date birthDate = new java.sql.Date(date.getTime());
         System.out.println(birthDate); //2020-08-09
     }
 ​
     @Test
     public void fish() throws ParseException {
         String Start = "1990-01-01";   //开始时间
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  //格式化
         Date date = sdf.parse(Start);  //转换为Date
         long startDate = date.getTime(); //变成时间戳，毫秒数
 ​
         String End = "2022-04-06";   //开始时间
         SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");  //格式化
         Date date1 = sdf1.parse(End);  //转换为Date
         long endDate = date1.getTime();
         //System.out.println(endDate);
         long cha = endDate - startDate;
         //System.out.println(cha);
         long dayfish = (cha /(1000 * 60 *60 *24 )) % 5;
         System.out.println(dayfish); //0
         if (dayfish< 4 && dayfish>0){
             System.out.println("我在打鱼啊");
         }else{
             System.out.println("我在晒网呢，没偷懒哦");
         }
     }
 }

1.4 java.util.Calendar(日历)类

• Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能。

• 注意： 获取月份时：一月是0，二月是1， 以此类推， 12月是11

  获取星期时：周日是1，周六是7

 /*
 Calendar日历类(抽象类)的使用
 ​
  */
 @Test
 public void testCalendar(){
     //1. 实例化
     //方式一： 创建其子类(GregorianCanlendar)的对象
     //方式二： 调用其静态方法getInstance()
     Calendar calendar = Calendar.getInstance();
     System.out.println(calendar.getClass());  //获得此类是哪个类造的，class java.util.GregorianCalendar
     //2. 常用方法
     //get()
     int days = calendar.get(Calendar.DAY_OF_MONTH);
     System.out.println(days); //7
     int weeks = calendar.get(Calendar.DAY_OF_WEEK);
     System.out.println(weeks); //5
     //set()
     calendar.set(Calendar.DAY_OF_MONTH, 22);  //进行了修改
     days = calendar.get(Calendar.DAY_OF_MONTH);
     System.out.println(days);  //22
     //add()
     calendar.add(Calendar.DAY_OF_MONTH, 3); // 在现有基础上，修改完之后的，加了三天
     days = calendar.get(Calendar.DAY_OF_MONTH);
     System.out.println(days);  //25
     //getTime(): 日历类 -->Date
     Date date = calendar.getTime();
     System.out.println(date);  //Mon Apr 25 11:17:27 CST 2022
     //setTime()
     Date date1 = new Date();
     calendar.setTime(date1);  //修改了calendar，所以会变回当前日期，7号
     days = calendar.get(Calendar.DAY_OF_MONTH);
     System.out.println(days);  //7
 ​
 }

2 JDK 8 中新日期时间API

• Date和Calendar都不太使用了，存在问题如下：

  • 可变性：像日期和时间这样的类应该是不可变的，即改变时应该赋予新的变量而不是改变calendar

  • 偏移性：Date中的月份是从1900开始的，而月份都从0开始

  • 格式化： 格式化只对Date有用，Calendar则不行

  • 此外，他们也不是线程安全的，不能处理闰秒等。

• 总结：对日期和时间的操作一直是java程序员最痛苦的地方之一。

2.1 新时间日期API

• 第三次引入的API是成功的，并且Java 8 中引入的Java.time API已经纠正了过去的缺陷。

  • java.time--包含值对象的基础包

  • java.time.chrono--提供对不同的日历系统的访问

  • java.time.format--格式化和解析时间和日期

  • Java.time.temporal--包含底层框架和扩展特性

  • Java.time.zone--包含时区支持的类

• 常用的几个类

  • LocalDate代表ISO格式(yyyy-MM-dd)的日期，可以存储生日、纪念日等日期

  • LocalTime表示一个时间，而不是日期

  • LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

 package com.xue.java1;
 ​
 import org.junit.Test;
 ​
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/7
  * Time: 15:56
  * Description: JDK8中日期时间API的测试
  */
 public class JDK8DateTimeTest {
     /*
     LocalTime、LocalDate、LocalDateTime的使用
     说明：
         1. LocalDateTime相较于LocalTime、LocalDate,使用频率更高
         2. 类似于Calendar
 ​
      */
     @Test
     public void test1(){
         //now()：获取当前的日期、时间、日期+时间
         LocalDate localDate = LocalDate.now();
         LocalTime localTime = LocalTime.now();
         LocalDateTime localDateTime = LocalDateTime.now();
         System.out.println(localDate); //2022-04-07
         System.out.println(localTime); //16:16:43.587530500
         System.out.println(localDateTime); //2022-04-07T16:16:43.587530500
 ​
         System.out.println("==========================================");
 ​
         //of()：设置指定的年月日时分秒，没有偏移量
         LocalDateTime localDateTime1 = LocalDateTime.of(2022, 04, 07, 16, 26, 25);
         System.out.println(localDateTime1); //2022-04-07T16:26:25
 ​
         //getXXX():获取相关属性
         System.out.println(localDateTime.getDayOfMonth());  //7
         System.out.println(localDateTime.getDayOfWeek());  //THURSDAY
         System.out.println(localDateTime.getMonth()); //APRIL
         System.out.println(localDateTime.getMonthValue()); //4
         System.out.println(localDateTime.getMinute()); //37
 ​
         System.out.println("==========================================");
 ​
         //体现不可变性
         //withXXX()：设置相关属性
         LocalDateTime localDateTime2 = localDateTime1.withDayOfMonth(22); //修改了当前日
         System.out.println(localDateTime1); //2022-04-07T16:26:25
         System.out.println(localDateTime2); //2022-04-22T16:26:25
 ​
         LocalDateTime localDateTime3 = localDateTime1.withHour(4); //修改了当前小时
         System.out.println(localDateTime1); //2022-04-07T16:26:25
         System.out.println(localDateTime3); //2022-04-07T04:26:25
 ​
         //不可变性，加，同时也有家的方法，minus
         LocalDateTime localDateTime4 = localDateTime1.plusMonths(3);
         System.out.println(localDateTime1);  //2022-04-07T16:26:25
         System.out.println(localDateTime4);  //2022-07-07T16:26:25
 ​
 ​
     }
 }

2.2 瞬时 Instant

• Instant：时间线上的一个瞬时点。这可能被用来记录应用程序中的时间时间戳。

• 在Java中从1970年开始，但是以毫秒为单位

方法	描述
now()	静态方法，返回默认UTC时区的Instant类的对象
ofEpochMilli(long epochMIlli)	静态方法，返回在1970-01-01 00:00:00基础上加上指定毫秒数之后Instant类的对象
atOffset(ZoneOffset offset)	结合及时的偏移来创建一个OffsetDate Time
toEpochMilli()	返回1970-01-01 00:00:00到当前时间的毫秒数，即为时间戳

 /*
 Instant的使用
 类似于java.util.Date类
  */
 @Test
 public void test2(){
     Instant instant = Instant.now();
     //now()：获取本初子午线对应的标准时间
     System.out.println(instant); //2022-04-07T12:53:44.204431500Z
 ​
     //8区，需要在这个基础上加上8个小时，实际时间为20时
     OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
     System.out.println(offsetDateTime);
 ​
     //获取对应的毫秒数，距离1970年1月1日0时0分0秒,和gettime()类似
     long milli = instant.toEpochMilli();
     System.out.println(milli);
 ​
     //ofEpochMilli()通过给定的毫秒数，获取Instant实例 -->Date(long millis)
     Instant instant1 = Instant.ofEpochMilli(1649336711805L);
     System.out.println(instant1);
 ​
 }

2.3 格式化与解析日期或时间

• java.time.format.DateTimeFormatter类：该类提供了三种格式化方法

方法	描述
ofPattern(String pattern)	静态方法，返回一个指定字符串格式的DateTimeFormatter
format(TemporalAccessor t)	格式化一个日期、时间，返回字符串
parse(CharSequence text)	将指定格式的字符序列解析为一个日期、时间

 /*
 DateTimeFormatter: 格式化或解析日期、时间
 类似于SimpleDateFormat
  */
 @Test
 public void test3(){
     //方式一： 预定义的标准格式。如： ISO_LOCAL_DATE_TIME; ISO_LOCAL_DATE; ISO_LOCAL_TIME
     DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
     //格式化： 日期 -->字符串
     LocalDateTime localDateTime = LocalDateTime.now();
     String str1 = formatter.format(localDateTime);
     System.out.println(str1);  //2022-04-07T21:25:15.1384803
     //解析： 字符串 -->日期
     TemporalAccessor parse = formatter.parse("2022-04-07T21:25:15.1384803");
     System.out.println(parse);  //{},ISO resolved to 2022-04-07T21:25:15.138480300
     System.out.println("================================================");
 ​
     //方式二： 本地化相关的格式。如： ofLocalizedDateTime(FormatStyle.LONG)
               //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDateTime
     DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT); //也可以换成LONG等形式
               //格式化
     String str2 = formatter1.format(localDateTime);
     System.out.println(str2); //2022/4/8 上午9:03
               // 本地化相关的格式。如： ofLocalizedDate()
               //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
     DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
     String str3 = formatter2.format(LocalDate.now()); //2022年4月8日星期五
     System.out.println(str3);
     System.out.println("================================================");
 ​
     //重点：  方式三： 自定义的格式，如： ofPattern("yyyy-MM-dd hh:MM:ss E")！！！！
     DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:MM:ss");
     //格式化
     String str4 = formatter3.format(localDateTime.now());
     System.out.println(str4);//2022-04-08 09:04:04
 ​
     //解析
     TemporalAccessor parse1 = formatter3.parse("2022-04-08 09:04:04");
     System.out.println(parse1); //{SecondOfMinute=4, MicroOfSecond=0, HourOfAmPm=9, NanoOfSecond=0, MilliOfSecond=0},ISO resolved to 2022-04-08
 }

2.4 其他API

• Zoneld：该类中包含了所有的时区信息，一个时区的ID，如Europe/Paris

• ZonedDateTime: 一个在ISO-8601日历系统时区的日期时间，如2007-12-03T10：15：30+01：00 Europe/Paris

  • 其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等

• Clock:使用时区提供对当前即时、日期和时间的访问的时钟

• 持续时间：Duration,用于计算两个"时间"间隔

• 日期间隔： Period，用于计算两个"日期"间隔

• TemporalAdjuster: 时间校正器。有时我们可能需要获取例如：将日期调整到"下一个工作日"等操作

• TemporalAdjusters: 该类通过静态方法(firstDayOfXxx() /lastDayOfXxx()/ nextXXxx())提供了大量的常用TemporalAdjuster的实现。

2.5 与传统日期处理的转换

3 java比较器

• 解决对象之间的比较问题

• Java实现对象排序的方式有两种

  • 自然排序：java.lang.Comparable

  • 定制排序：java.util.Comparator

3.1 自然排序： java.lang.Comparable

• Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

• 实现Comparable的类必须实现compareTo(Object obj)方法，两个对象即通过compare To(Object obj)方法的返回值来比较大小。如果当前对象this大于形参对象obj,则返回正整数，如果当前对象this小于形参对象obj,则返回负整数，如果当前对象this等于形参对象obj,则返回零。

• 实现Comparable接口的对象列表(和数组)可以通过Collections.sort或Arrays sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

• 对于类C的每一个e1和e2来说，当且仅当e1.compareTo(e2)==0与e1.equals(e2)具有相同的boolean值时，类C的自然排序才叫做与equals一致。 建议(虽然不是必需的)最好使自然排序与equals一致。

 package com.xue.java1;
 ​
 import org.junit.Test;
 ​
 import java.util.Arrays;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/8
  * Time: 15:44
  * Description: 一、说明：Java中的对象，正常情况下，只能进行比较： == 或！=。不能使用>或者<的
  *              二、Comparable接口的使用
  */
 public class CompareTest {
 ​
     /*
     Comparable接口的使用举例 ：自然排序
         1. 像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方式
         2. 像String、包装类等重写了compareTo()方法以后，进行了从小到大的排列。
         3. 重写compareTo()的规则：
            如果当前对象this大于形参对象obj，则返回正整数，
            如果当前对象this小于形参对象obj，则返回负整数，
            如果当前对象this等于形参对象obj，则返回零。
         4. 对于自定义类，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo()方法；
            在compareTo(obj)方法中指明如何排序
 ​
      */
     @Test
     public void test1(){  //像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方式
         String[] arr = new String[]{"AA", "CC", "GG", "MM", "DD"};
         Arrays.sort(arr);
         System.out.println(Arrays.toString(arr)); //[AA, CC, DD, GG, MM]
         System.out.println("****************************************************************");
     }
 ​
     
     
     @Test
     public void test2(){
         Goods[] arr = new Goods[4];   //自定义类，如果需要排序，重写compareTo()方法，需要指明排序的规则
         arr[0] = new Goods("lianxiangMouse", 34);
         arr[1] = new Goods("dellMouse", 12);
         arr[2] = new Goods("xiaomiMouse", 5);
         arr[3] = new Goods("huaweiMouse", 65);
 ​
         Arrays.sort(arr);  //加了*证明，调用sort使用了comparable方法
         System.out.println(Arrays.toString(arr)); 
 /*输出结果为：
 ******
 ******
 ******
 ******
 ******
 ******
 ******
 [Goods{name='xiaomiMouse', price=5.0}, Goods{name='dellMouse', price=12.0}, Goods{name='lianxiangMouse', price=34.0}, Goods{name='huawehMouse', price=65.0}, Goods{name='huaweiMouse', price=65.0}]
 */
     }
 ​
 ​
 ​
 }

商品类程序如下：alt+enter,重写comparable的方法

 package com.xue.java1;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/8
  * Time: 16:35
  * Description: 商品类
  */
 public class Goods implements Comparable{  //选中Comparable，alt+enter,重写comparable的方法
     private String name;
     private double price;
 ​
     public Goods() {
     }
 ​
     public Goods(String name, double price) {
         this.name = name;
         this.price = price;
     }
 ​
     public String getName() {
         return name;
     }
 ​
     public void setName(String name) {
         this.name = name;
     }
 ​
     public double getPrice() {
         return price;
     }
 ​
     public void setPrice(double price) {
         this.price = price;
     }
 ​
     @Override
     public String toString() {
         return "Goods{" +
                 "name='" + name + '\'' +
                 ", price=" + price +
                 '}';
     }
 ​
     //指明商品按照什么方法进行排序：价格从低到高排序，再按照名称从高到低
     @Override
     public int compareTo(Object o) {
         System.out.println("******");
         if (o instanceof Goods){  //确定是不是商品
             Goods goods = (Goods)o; //对o进行强转
             if(this.price > goods.price){
                 return 1;
             }else if(this.price < goods.price){
                 return -1;
             }else{
                 return 0;
             }
         }
         throw new RuntimeException("传入的数据类型不一致");
     }
 }

3.2 定制排序：java.util.Comparator

• 当元素的类型没有实现Java.lang.Comparable接口而又不方便修改代码，或者实现了Java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用Comparator的对象来排序。

• 重写compare(Object o1, Object o2)的方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回值为0，表示相等；返回负整数，表示o1小于o2.

• 可以将Comparator传递给sort方法(如Collections.sort或Arrays.sort)，从而允许在排序顺序上实现精确控制

• 还可以使用Comparator来控制某些数据结构(如有序set或有序映射)的顺序，或者为那些没有自然顺序的对象collection提供排序。

 /*
 Comparator接口的使用举例 ：定制排序
 1. 背景：
 当元素的类型没有实现Java.lang.Comparable接口而又不方便修改代码，
 或者实现了Java.lang.Comparable接口的排序规则而不适合当前的操作。
 2. Comparator类里边有compare方法，需要重写
 3. 重写compare(Object o1, Object o2)的方法，比较o1和o2的大小：
    如果方法返回正整数，则表示o1大于o2；
    如果返回值为0，表示相等；
    返回负整数，表示o1小于o2。
  */
 @Test
 public void test3(){
     String[] arr = new String[]{"AA", "CC", "GG", "MM", "DD"};
     Arrays.sort(arr, new Comparator(){
     //按照字符从大到小顺序排列
         @Override
         public int compare(Object o1, Object o2) {
             if(o1 instanceof String && o2 instanceof String){
                 String s1 = (String)o1;
                 String s2 = (String)o2;
                 return -s1.compareTo(s2); //改成从大到小排了
             }
             //return 0;
             throw new RuntimeException("传入的数据类型不一致");
         }
     });
     System.out.println(Arrays.toString(arr));  //[MM, GG, DD, CC, AA]
     System.out.println("****************************************************************");
 }
 ​
 @Test
 public void test4(){
     Goods[] arr = new Goods[5];
     //自定义类，如果需要排序，重写compareTo()方法，需要指明排序的规则
     arr[0] = new Goods("lianxiangMouse", 34);
     arr[1] = new Goods("dellMouse", 12);
     arr[2] = new Goods("xiaomiMouse", 5);
     arr[3] = new Goods("huaweiMouse", 65);
     arr[4] = new Goods("huaweiMouse", 100);
 ​
     Arrays.sort(arr, new Comparator(){
         //指明商品按照什么方法进行排序：按照产品名称从低到高，再价格从高到低
         @Override
         public int compare(Object o1, Object o2) {
             if(o1 instanceof Goods && o2 instanceof Goods){
                 Goods g1 = (Goods)o1;
                 Goods g2 = (Goods)o2;//强转
                 if (g1.getName().equals(g2.getName())){
                     return -Double.compare(g1.getPrice(), g2.getPrice());
                     //因为compare默认从低到高，我们要从高到低，需要加负号
                 }else{
                     return g1.getName().compareTo(g2.getName());
                 }
             }
             throw new RuntimeException("传入的数据类型不一致");
         }
     });
     System.out.println(Arrays.toString(arr));
     /*
     输出结果为：
     [Goods{name='dellMouse', price=12.0}, Goods{name='huaweiMouse', price=100.0}, Goods{name='huaweiMouse', price=65.0}, Goods{name='lianxiangMouse', price=34.0}, Goods{name='xiaomiMouse', price=5.0}]
      */
 }

3.3 comparable接口与comparator比较

• comparable接口与comparator使用对比

  • comparable接口的方式一旦指定，能够保证comparable接口实现类的对象在任何位置都可以比较大小。

  • Comparator接口属于临时性的比较。（什么时候需要什么时候创建，不需要单独创建一个商品类）

4 System类

• System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

• 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

• 成员变量

  • System类内部包含in、out和err三 个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

• 成员方法

  • native long currentTimeMillis():

    该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

  • void exit(int status): 该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

  • void gc():

    该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

  • String getProperty(String key):

    该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示:

属性名	属性说明
java. version	Java运行时环境版本
java. home	Java安装目录
os. name	操作系统的名称
os. version	操作系统的版本
user. name	用户的账户名称
user. home	用户的主目录
user. dir	用户的当前工作目录

 package com.xue.java1;
 ​
 import org.junit.Test;
 ​
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/8
  * Time: 22:07
  * Description:其他常用类的使用
  * 1. System
  * 2. math
  * 3. BigIntegar和BigDecimal
  */
 public class OtherClassTest {
     @Test
     public void test1(){
         String javaVersion = System.getProperty(" java.version" );
         System.out.println("javaversion:" + javaVersion);
 ​
         String javaHome = System.getProperty("java.home");
         System.out.println("javahome:" + javaHome);
 ​
         String osName = System.getProperty("os.name" );
         System.out.println("osÁJname:" +osName);
 ​
         String osVersion = System.getProperty( "os.version" );
         System.out.println("os的version:" + osVersion);
 ​
         String userName = System.getProperty("user.name" ) ;
         System.out.println("user的name:" + userName);
 ​
         String userHome = System.getProperty("user.home");
         System.out.println("user的home:" + userHome);
 ​
         String userDir = System.getProperty("user.dir");
         System.out.println("user的dir:" + userDir);
 ​
     }
 ​
 }

输出结果为：

 javaversion:null
 javahome:D:\Xin_Downloads\IntelliJ IDEA 2019.2\jbr
 osÁJname:Windows 10
 os的version:10.0
 user的name:xinxueqi
 user的home:C:\Users\xinxueqi
 user的dir:F:\Seven\UnderTheSecond\0\FrontOrBack\JAVA\code\code1\基础语法补充

5 Math类

• java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般 为double型。

• abs 绝对值

• acos,asin,atan,cos,sin,tan 三角函数

• sqrt 平方根

• pow(double a,doble b) a的b次幂

• log 自然对数

• exp e为底指数

• max(double a,double b)

• min(double a,double b)

• random() 返回0.0到1.0的随机数

• long round(double a) double型数据a转换为long型(四舍五入)

• toDegrees(double angrad) 弧度- -> 角度

• toRadians(double angdeg) 角度一>弧度

6 BigInteger与BigDecimal

6.1 BigInteger

• Integer类作为int的包装类，能存储的最大整型值为(2^31)-1，Long类也是有限的，最大为(2^63)-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

• java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger提供所有Java的基本整数操作符的对应物，并提供java.lang.Math的所有相关方法。另外，BigInteger 还提供以下运算:模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作。

• 构造器

  • BigInteger(String val): 根据字符串构建BigInteger对象

• 常用方法

  • public Biglnteger abs(): 返回此BigInteger的绝对值的BigInteger。

  • BigInteger add(BigInteger val) : 返回其值为(this + val)的BigInteger。

  • BigInteger subtract(BigInteger val) : 返回其值为(this - val)的BigInteger。

  • BigInteger multiply(BigInteger val) : 返回其值为(this * val)的BigInteger。

  • BigInteger divide(BigInteger val) : 返回其值为(this / val)的BigInteger。

  • BigInteger remainder(BigInteger val): 返回其值为(this % val)的BigInteger。

  • BigInteger[] divideAndRemainder(BigInteger val): 返回包含(this / val)后跟(this % val)的两个BigInteger的数组。

  • BigInteger pow(int exponent): 返回其值为(this^exponent)的BigInteger。

6.2 BigDecimal类

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类 。

• BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

• 构造器

  • public BigDecimal(double val)

  • public BigDecimal(String val)

• 常用方法

  • public BigDecimal add(BigDecimal augend)

  • public BigDecimal subtract(BigDecimal subtrahend)

  • public BigDecimal multiply(BigDecimal multiplicand)

  • public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

 @Test
     public void test2(){
         BigInteger bi = new BigInteger("12433241123456465465123156465" );
         BigDecimal bd = new BigDecimal("12435.351");
         BigDecimal bd2 = new BigDecimal("11");
         System.out.println(bi); //12433241123456465465123156465
 ​
 //        System.out.println(bd.divide(bd2)); //需要指定精度
         System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));  //1130.486
         System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
         //1130.486454545454545. 15位小数
 ​
     }

7 作业及复习

• JDK8之前和JDK8中日期、时间相关的类分别有哪些？

• java.util.Date和java.sql.Date --》Instant

• SimpleDateFormat --> DateTimeForamatter

• Calendar -->LocalDate, LocalTime, LocalDateTime

7.1 日期API的迭代

• 第一代：jdk1.0 Date

• 第二代：jdk1.1 Calendar，一定程度上替换了Date

• 第三代：jdk1.8 提出了一套新的API

• 前两代存在的问题：

  • 可变性

  • 偏移性：Date中的年份都是从1900开始的，而月份都从0开始

  • 格式化：格式化只对Date用，Calendar则不行

  • 此外，他们线程不是安全的，不能处理闰秒

     

 

 

 

 

 

 

 

 

知识补充

• new的是子类，引用对象是父类，那么可以强转，但是如果new的就是父类，那么一定不能强转。

• SimpleDateFormat.parse针对的是字符 -->date型,用来解析；SimpleDateFormat.format针对的是date型 -->字符串，用来格式化。

1 IDEA的使用--module的导入

• 从别人那复制过来的没有module文件，所以需要导入module

• 进入IDEA界面 -->右上角的Project Structure点击 -->进入之后点击+ -->import module -->找到需要加入module的文件 -->之后一直默认next

2. 重写Comparable

• alt+enter,重写comparable的方法

3. 静态方法不能重写

4 编码与解码

• 编码：字符串按照某种编码集-->字节

• 解码：字节 -->字符串

5 格式化与解析

• 格式化： 日期 -->字符串

• 解析： 字符串-->日期

6 接口定义规范，sort执行具体排序