一：JDK 8之前的日期时间API

（1）System静态方法

java.lang.System类：

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

  2. 此方法适用于计算时间差。

    计算世界时间的主要标准有：

  3. UTC

  4. GMT
  5. CST

    （2）Date类

    java.util.Date类：

    表示特定的瞬间，精确到毫秒。
    1. /**
    2. * java.util.Date类
    3. *      |java.sql.Date类（二者具有子父类关系）
    4. * 1.两个构造器的使用：
    5. *      Date();使用无参构造器创建时间对象可以获取本地当前时间。
    6. *      Date(long date);创建一个指定时间的Date对象。
    7. * 2.两个方法的使用：
    8. *      getTime();返回自1970年1月1日0时0分0秒GMT以来此Date对象表示的毫秒数。
    9. *      toString();把此Date对象转为以下形式的String：dow mon dd hh:mm:ss zzz yyyy。其中：dow是一周中的某一天，zzz是时间标准。
    10. * 3.java.sql.Date类对应着数据库中的日期类型的变量。
    11. *      (1)如何实例化？
    12. *      (2)如何将java.util.Date对象转换为sql.Date对象？
    13. */
    14. public class DateTimeTest {
    15.  public static void main(String[] args) {
    16.      //构造器1：Date()：创建一个对应当前时间的Date对象。
    17.      Date date1 = new Date();
    18.      System.out.println(date1);//Thu Dec 10 18:24:37 CST 2020
    19.      //方法1：getTime()
    20.      System.out.println(date1.getTime());//1607595972489
    21.      //方法2：toString()
    22.      System.out.println(date1.toString());//Thu Dec 10 18:24:37 CST 2020
    23.      //构造器2：Date(long date)：创建一个指定时间的Date对象。
    24.      Date date2 = new Date(56275723575L);
    25.      System.out.println(date2.toString());//Thu Oct 14 16:08:43 CST 1971
    26.      //java.sql.Date
    27.      //(1)实例化java.sql.Date类
    28.      java.sql.Date date3 = new java.sql.Date(482658287484L);
    29.      System.out.println(date3.toString());//1985-04-18
    30.      //(2)将java.util.Date对象转换为sql.Date对象
    31.      //情况一:
    32.      Date date4 = new java.sql.Date(482658287484L);
    33.      java.sql.Date date5 = (java.sql.Date)date4;
    34.      //情况二：
    35.      Date date6 = new Date(482658287999L);
    36.      java.sql.Date date7 = new java.sql.Date(date6.getTime());//用date6.getTime()作为中转
    37.  }
    38. }

    （3）Calendar

    java.util.Calendar(日历)类
    Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能。
    1. /**
    2. * Calendar日历类（抽象类）的使用
    3. */
    4. public class CalendarTest {
    5.  public static void main(String[] args) {
    6.      //1.实例化
    7.      //方式一：使用Calendar.getInstance()方法
    8.      //方式二：调用它的子类GregorianCalendar的构造器
    9.      Calendar calendar = Calendar.getInstance();
    10.      //System.out.println(calendar.getClass());//返回结果：class java.util.GregorianCalendar。getClass()：看它属于哪个类
    11.      //2.常用方法
    12.      //get():返回这一周/月/年的第多少天
    13.      int days = calendar.get(Calendar.DAY_OF_MONTH);
    14.      System.out.println("测试时间为2020-12-11，它是这个月的第"+days+"天。");//测试时间为2020-12-11，它是这个月的第11天。
    15.      System.out.println("测试时间为2020-12-11，它是这一年的第"+calendar.get(Calendar.DAY_OF_YEAR)+"天。");//测试时间为2020-12-11，它是这一年的第346天。
    16.      //set():将原本的***修改为***
    17.      calendar.set(Calendar.DAY_OF_MONTH,22);
    18.      days = calendar.get(Calendar.DAY_OF_MONTH);
    19.      System.out.println(days);//22
    20.      //add():在现有的基础上加***天（减几天的话就是加一个负数）
    21.      calendar.add(Calendar.DAY_OF_MONTH,3);
    22.      days = calendar.get(Calendar.DAY_OF_MONTH);
    23.      System.out.println(days);//25
    24.      //getTime()：日历类-->Date
    25.      Date date = calendar.getTime();
    26.      System.out.println(date);//Fri Dec 25 09:16:54 CST 2020
    27.      //setTime():Date-->日历类
    28.      Date date1 = new Date();
    29.      calendar.setTime(date1);
    30.      days = calendar.get(Calendar.DAY_OF_MONTH);
    31.      System.out.println(days);//11
    32.  }
    33. }

    （4）SimpleDateFormat类

    java.text.SimpleDateFormat类：

    Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
    1. /**
    2. * java.text.SimpleDateFormat的使用
    3. * 两个操作：
    4. *   1.格式化：日期--->字符串
    5. *      SimpleDateFormat():默认的模式和语言环境创建对象。
    6. *      public SimpleDateFormat(String pattern):该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
    7. *      pubic String format(Date date):方法格式化时间对象date.
    8. *   2.解析：字符串--->日期
    9. *      public Date parse(String source):从给定的字符串的开始解析文本，以生成一个日期。
    10. *   3.注意：
    11. *      获取月份时：一月是0，二月是1……十二月是11.
    12. *      获取星期时：周日是1，周二是2……周六是7.
    13. */
    14. public class SimpleDateFormatTest {
    15.  public static void main(String[] args) throws ParseException {
    16.       //SimpleDateFormat的实例化:使用默认格式
    17.      SimpleDateFormat sdf = new SimpleDateFormat();
    18.      //格式化
    19.      Date date = new Date();
    20.      String format = sdf.format(date);
    21.      System.out.println("格式化为："+format);//格式化为：2020/12/11 上午8:13
    22.      //解析
    23.      String str = "2020/12/11 上午8:09";//此字符串有格式上的要求,例如：2020/12/11 上午8:09
    24.      Date date1 = sdf.parse(str);
    25.      System.out.println("解析为："+date1);//解析为：Fri Dec 11 08:09:00 CST 2020
    26.      //**********按照指定的方式进行格式化和解析：调用带参的构造器*********
    27.      SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy.MMMM.dd GGG hh:mm aaa");
    28.      String format1 = sdf1.format(date);
    29.      System.out.println(format1);//2020.十二月.11 公元 08:17 上午
    30.      //**********按照指定的方式进行格式化和解析：调用带参的构造器*********
    31.      SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    32.      String format2 = sdf2.format(date);
    33.      System.out.println(format2);//2020-12-11 08:19:36
    34.      //********解析********
    35.      Date date2 = sdf1.parse("2020.十二月.11 公元 08:17 上午");
    36.      System.out.println(date2);//Fri Dec 11 08:17:00 CST 2020
    37.  }
    38. }

    二：JDK 8中新日期时间API（重要）

    （1）LocalDate、LocalTime、LocalDateTime

    1. /**
    2. * LocalDate、LocalTime、LocalDateTime的使用
    3. * 说明：
    4. *    1.LocalDateTime相较于LocalDate、LocalTime的使用频率要高。
    5. *    2.类似于Calendar
    6. */
    7. public class LocalTimeTest {
    8.  public static void main(String[] args) {
    9.      //now():获取当前的日期、时间、日期+时间
    10.      LocalDate localDate = LocalDate.now();
    11.      LocalTime localTime = LocalTime.now();
    12.      LocalDateTime localDateTime = LocalDateTime.now();
    13.      System.out.println("日期是："+localDate);//日期是：2020-12-11
    14.      System.out.println("时间是："+localTime);//时间是：09:42:08.969828600
    15.      System.out.println("日期和时间是:"+localDateTime);//日期和时间是:2020-12-11T09:42:08.969828600
    16.      //of():设置指定的年、月、日、时、分、秒,没有偏移量
    17.      LocalDateTime localDateTime1 = LocalDateTime.of(2020, 11, 11, 11, 11, 11);
    18.      System.out.println(localDateTime1);//2020-11-11T11:11:11
    19.      //*****具体操作**********
    20.      //getXXX():获取
    21.      System.out.println(localDateTime.getDayOfYear());//346
    22.      System.out.println(localDateTime.getDayOfMonth());//11
    23.      System.out.println(localDateTime.getDayOfWeek());//FRIDAY
    24.      System.out.println(localDateTime.getMonth());//DECEMBER
    25.      System.out.println(localDateTime.getMinute());//49
    26.      //withXXX():体现不可变性
    27.      LocalDate localDate1 = localDate.withDayOfMonth(22);
    28.      System.out.println(localDate);//2020-12-11
    29.      System.out.println(localDate1);//2020-12-22
    30.      //plusXXX():体现不可变性（加操作）。minusXXX():减操作
    31.      LocalDate localDate2 = localDate.plusDays(3);
    32.      System.out.println(localDate);//2020-12-11
    33.      System.out.println(localDate2);//2020-12-14
    34.  }
    35. }

    （2）Instant

    1. /**
    2. * Instant（瞬时点）的使用
    3. *      类似于java.util.Date类
    4. */
    5. public class InstantTest {
    6.  public static void main(String[] args) {
    7.      //now():获取本初子午线对应的时间
    8.      Instant instant = Instant.now();
    9.      System.out.println(instant);//2020-12-11T02:15:25.658140700Z。(比我们的时间慢八个小时)
    10.      //添加时间的偏移量
    11.      OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    12.      System.out.println(offsetDateTime);//2020-12-11T10:18:44.683054+08:00
    13.      //获取自1970年……开始到现在的毫秒数
    14.      long milli = instant.toEpochMilli();
    15.      System.out.println(milli);//1607653304856
    16.      //ofEpochMilli():通过指定的毫秒数，获取Instant实例
    17.      Instant instant1 = Instant.ofEpochMilli(1607653304856L);
    18.      System.out.println(instant1);//2020-12-11T02:21:44.856Z
    19.  }
    20. }

    （3）DateTimeFormatter

    1. /**
    2. * DateTimeFormatter:格式化或解析日期、时间
    3. *    类似于SimpleDateFormat
    4. *  1.预定义的标准格式.如：
    5. *       ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
    6. *  2.本地化相关的格式。如：ofLocalizedDate Time(FormatStyle.LONG)
    7. *  3.（开发中用的多）自定义的格式。如ofPattern("yyyy-MM-dd hh:mm:ss E")
    8. *      ofPattern(String pattern):静态方法，返回一个指定字符串格式的DateTimeFormattter。
    9. *      format(TemporalAccessor t):格式化一个日期、时间，返回字符串。
    10. *      parse(CharSequence text):将指定格式的字符串序列解析为一个日期、时间
    11. */
    12. public class DateTimeFormatterTest {
    13.  public static void main(String[] args) {
    14.      //方式一：预定义的标准格式.
    15.      DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    16.      //格式化：日期-->字符串
    17.      LocalDateTime localDateTime = LocalDateTime.now();
    18.      String str1 = formatter.format(localDateTime);
    19.      System.out.println(localDateTime);//2020-12-11T10:54:26.738156200
    20.      System.out.println(str1);//2020-12-11T10:54:26.7381562
    21.      //解析：字符串——>日期
    22.      TemporalAccessor parse = formatter.parse("2020-12-11T10:54:26.7381562");
    23.      System.out.println(parse);//{},ISO resolved to 2020-12-11T10:54:26.738156200
    24.      //*********
    25.      //重点：自定义的格式。如ofPattern("yyyy-MM-dd hh:mm:ss E")
    26.      DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
    27.      //格式化
    28.      String str3 = formatter1.format(LocalDateTime.now());
    29.      System.out.println(str3);//2020-12-11 11:03:25
    30.      //解析
    31.      TemporalAccessor accessor = formatter1.parse("2020-12-11 11:03:25");
    32.      System.out.println(accessor);//{SecondOfMinute=25, MicroOfSecond=0, MinuteOfHour=3, HourOfAmPm=11, MilliOfSecond=0, NanoOfSecond=0},ISO resolved to 2020-12-11
    33.  }
    34. }

    三：Java比较器（重点）

    （1）Comparable接口

    自然排序：java.lang.Comparable ```java /**
    • java比较器。
    • 一；说明：
    • Java中的对象，正常情况下，只能进行比较：== 或 ！=。不能使用>或<。但是在开发场景中，我们需要对多个对象进行排序，
    • 言外之意，就需要比较对象的大小。如何实现？
    • 使用两个接口中的任何一个：Comparable接口或Comparator接口。
    • 二：自然排序：java.lang.Comparable
    • 1.像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方式。
    • 2.像String、包装类重写compareTo()方法以后，进行从小到大的排列
    • 3.重写compareTo()规则：
    • (1)如果当前对象this大于形参对象abj，则返回正整数。
    • (2)如果当前对象this小于形参对象abj，则返回负整数。
    • (3)如果当前对象this等于形参对象abj，则返回零。
    • 4.对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo()方法。在方法中指明如何排序。 */ //商品类 class Goods implements 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{“ +
      1.   "name='" + name + '\'' +
      2.   ", price=" + price +
      3.   '}';
      } //指明商品比较大小的方式：先按照价格从低到高排序，再按照姓名从高到低排序 @Override public int compareTo(Object o) { if (o instanceof Goods){ Goods goods = (Goods)o; //方式一： if (this.price > goods.price){
      1.   return 1;
      }else if(this.price < goods.price){
      1.   return -1;
      }else {
      1.   return -this.name.compareTo(goods.name);
      } //方式二： //return Double.compare(this.price,goods.price); } //如果不是商品如何处理 throw new RuntimeException(“传入的数据类型不一致！”); }

} //测试 public class CompareTest { public static void main(String[] args) { Goods[] arr = new Goods[5]; arr[0] = new Goods(“联想鼠标”,130); arr[1] = new Goods(“戴尔鼠标”,200); arr[2] = new Goods(“小米鼠标”,170); arr[3] = new Goods(“华为鼠标”,400); arr[4] = new Goods(“苹果鼠标”,400); Arrays.sort(arr);//排序 System.out.println(Arrays.toString(arr));//[Goods{name=’联想鼠标’, price=130.0}, Goods{name=’小米鼠标’, price=170.0}, Goods{name=’戴尔鼠标’, price=200.0}, Goods{name=’苹果鼠标’, price=400.0}, Goods{name=’华为鼠标’, price=400.0}] } }

  1. <a name="mulsf"></a>
  2. ### （2）Comparator接口
  3. 定制排序：java.util.Comparator
  4. ```java
  5. 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用Comparator的对象来排序，强行对多个对象进行整体排序的比较。
  6. 重写compare(Object o1,Object o2)方法，比较o1和o2的大小:如果方法返回正整数，则表示o1大于o2;如果返回0，表示相等;返回负整数，表示o1小于o2。
  7. 可以将Comparator传递给sort方法(如Collections.sort或Arrays.sort)，从而允许在排序顺序上实现精确控制。
  8. 还可以使用Comparator来控制某些数据结构(如有序set或有序映射)的顺序，或者为那些没有自然顺序的对象collection提供排序。
  1. public static void test1(){
  2.         String[] arr = new String[]{"AA","CC","KK","MM","GG","DD","LL","CC"};
  3.         Arrays.sort(arr, new Comparator<String>() {
  4.             //按照字符串从大到小排序
  5.             @Override
  6.             public int compare(String o1, String o2) {
  7.                 if (o1 instanceof String && o2 instanceof String){
  8.                     return o1.compareTo(o2);
  9.                 }
  10.                 throw new RuntimeException("类型不一致！");
  11.             }
  12.         });
  13.         System.out.println(Arrays.toString(arr));//[AA, CC, CC, DD, GG, KK, LL, MM]
  14.     }

四：System类

  1. System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
  2. 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
  4. 成员变量：
  5. System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)、和标准错误输出流(显示器)。
  7. 成员方法：
  8. native long currentTimeMillis():该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
  9. void exit(int status):该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
  10. void gc():该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法以及系统执行时的情况。
  11. String getProperty(String key):该方法的作用是获得系统中属性名为key的属性对应的值。

五：Math类

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

六：BigInteger与BigDecimal