常用类（五）System类

(1)System类常见方法和案例：

（1）exit:退出当前程序

我们设计的代码如下所示：

package com.ypl.System_;

public class System_ {
    public static void main(String[] args) {
        //exit: 退出当前程序
        System.out.println("ok1");
        //1.exit(0)表示程序退出
        //2. 0表示一个状态，正常的状态
        System.exit(0);  
        System.out.println("ok2");
    }
}

我们运行之后如下所示：

 

 （2）arraycopy: 复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组。

我们设计的代码如下所示：

package com.ypl.System_;

import java.util.Arrays;

public class System_ {
    public static void main(String[] args) {
      
        int[] src={1,2,3};
        int[] dest= new int[3]; //dest当前是{0，0，0}
        int[] dest1= new int[3]; //dest当前是{0，0，0}
        int[] dest2= new int[3]; //dest当前是{0，0，0}
        //1.主要是搞清楚这五个参数的含义
        //2.src – the source array.  (源数组）
        // srcPos – starting position in the source array. （从源数组的哪个索引位置开始拷贝）
        // dest – the destination array.  （目标数组，即把源数组的数据拷贝到哪个数组）
        // destPos – starting position in the destination data. （把源数组的数据拷贝到目标数组的哪个索引）
        // length – the number of array elements to be copied. （从源数组拷贝多少个数据到目标数组）
        System.arraycopy(src,0,dest,0,3); //[1,2,3]
        System.out.println("dest="+ Arrays.toString(dest));
        System.arraycopy(src,0,dest1,1,2);//[0,1,2]
        System.out.println("dest1="+Arrays.toString(dest1));
        System.arraycopy(src,0,dest2,1,src.length-1);//[0,1,2]
        System.out.println("dest2="+Arrays.toString(dest2));
    }
}

运行之后如下所示：

 

 （3）currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数(称为时间戳）

我们设计的代码如下所示：

package com.ypl.System_;

import java.util.Arrays;

public class System_ {
    public static void main(String[] args) {
        //currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
        //
        System.out.println(System.currentTimeMillis());
    }
}

我们运行之后如下所示：

 我们从菜鸟教程的API查看如下所示:

（4）gc:运行垃圾回收机制 System.gc( ).

（5）String getProperty(String key):

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

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

(2)BigInteger和BigDecimal

应用场景：

（1）BigInteger适合保存比较大的整型

（2）BigDecimal适合保存精度更高的浮点型（小数）

BigInteger

我们查看BigInteger的类图如下所示：

我们发现BigInteger里面有许多方法。

我们设计代码如下所示：

package com.ypl.bignum;

import java.math.BigInteger;

public class BigInteger_ {
    public static void main(String[] args) {
        long l=23788888999l;
        System.out.println("l="+l);
        //当我们编程中，需要处理很大的整数，long 不够用
        //可以使用BigInteger的类来搞定
        long l1=2378888899999999l;
        System.out.println("l1="+l1);

        BigInteger bigInteger = new BigInteger("237888889999999999999");
        BigInteger bigInteger1 = new BigInteger("100");
        System.out.println(bigInteger);
        //1.在对BigInteger进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
        //2.可以创建一个要操作的BigInteger,然后进行相应操作。
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add); //加
        BigInteger subtract = bigInteger.subtract(bigInteger1);
        System.out.println(subtract); //减法
        BigInteger multiply = bigInteger.multiply(bigInteger1);
        System.out.println(multiply); //乘
        BigInteger divide = bigInteger.divide(bigInteger1);
        System.out.println(divide); //除法

    }
}

 我们运行之后如下所示：

我们下来查看BigDecimal:

我们设计的代码如下所示：

package com.ypl.bignum;

import java.math.BigDecimal;

public class BigDecimal_ {
    public static void main(String[] args) {

        //当我们需要保存一个精度很高的数时，double不够用
        //可以使用BigDecimal
        double d=1999.1111111111111d;
        System.out.println(d);
        double c=1999.5555555555555555555; //会进行精度的缩减
        System.out.println(c);
        BigDecimal bigDecimal = new BigDecimal("1999.555555555555555555");
        BigDecimal bigDecimal1 = new BigDecimal("1.1");
        System.out.println(bigDecimal);
        //1.如果对BigDecimal进行运算，比如加减乘除，需要使用对应的方法
        //2.创建一个需要操作的BigDecimal然后调用相应的方法即可
        BigDecimal add = bigDecimal.add(bigDecimal1); //加
        System.out.println(add);
        BigDecimal subtract = bigDecimal.subtract(bigDecimal1);//减
        System.out.println(subtract);
        BigDecimal multiply = bigDecimal.multiply(bigDecimal1); //乘
        System.out.println(multiply);
        BigDecimal divide = bigDecimal.divide(bigDecimal1);//除，可能抛出异常，在算除法的时候是可能除不尽的，
        // 除不尽会抛出异常，除尽则不会
        System.out.println(divide);

    }
}

我们运行之后如下所示:

发现抛出异常，我们的解决方案如下所示：

package com.ypl.bignum;

import java.math.BigDecimal;

public class BigDecimal_ {
    public static void main(String[] args) {

        //当我们需要保存一个精度很高的数时，double不够用
        //可以使用BigDecimal
        double d=1999.1111111111111d;
        System.out.println(d);
        double c=1999.5555555555555555555; //会进行精度的缩减
        System.out.println(c);
        BigDecimal bigDecimal = new BigDecimal("1999.555555555555555555");
        BigDecimal bigDecimal1 = new BigDecimal("1.1");
        System.out.println(bigDecimal);
        //1.如果对BigDecimal进行运算，比如加减乘除，需要使用对应的方法
        //2.创建一个需要操作的BigDecimal然后调用相应的方法即可
        BigDecimal add = bigDecimal.add(bigDecimal1); //加
        System.out.println(add);
        BigDecimal subtract = bigDecimal.subtract(bigDecimal1);//减
        System.out.println(subtract);
        BigDecimal multiply = bigDecimal.multiply(bigDecimal1); //乘
        System.out.println(multiply);
     //   BigDecimal divide = bigDecimal.divide(bigDecimal1);//除，可能抛出异常，在算除法的时候是可能除不尽的，
        // 除不尽会抛出异常，除尽则不会
        //在调用divide方法时，指定精度即可,BigDecimal.ROUND_CEILING
        //如果有无限循环小数就会保留分子的精度
        BigDecimal divide = bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING);
        System.out.println(divide);

    }
}

我们运行之后如下所示：

我们发现完美解决。 

 （3）Date介绍

1.Date:精确到毫秒，代表特定的瞬间

2.SimpleDateFormat:格式化和解析日期的类

SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化（日期-->文本（字符串））、解析：格式化的逆过程，（文本（字符串）->日期）和规范化

我们查看类的关系继承图：

 我们查看他的方法，发现里面有很多方法，同时也有很多过时的方法：

 我们了解里面properties的相关：properties指的并不是我们的字段，而是如果我们的类里面有get和set的相关方法，就会把后面的名称自动当作一个properties。

我们通过具体案例来进行了解：
我们设计代码如下所示：

package com.ypl.data_;

public class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void cry(){

    }
    class Air{

    }
    //说明一下diagram IDEA properties 的含义
    public void  setAddress(String address){

    }
    public double getSalary( ){
        return 1.1;
    }
}

我们点击了properties之后，我们发现出现salary和address.

 我们没有点击之后，我们发现出现如下所示：出现了setAddress和getSalsry方法。

我们设计的代码如下所示：

package com.ypl.data_;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * java.util.Date类
 *       |java.sql.Date类
 *       1.两个构造器的使用
 *       2.两个方法的使用
 *       >toString():显示当前的年、月、日、时、分、秒
 *       >getTime():获取当前Date对象对应的毫秒数、时间戳
 *
 *       3.java.sql.Date对应着数据库中的日期类型的变量
 *       >如何实例化
 *       >如何将java.util.Date转化为java.sql.Date对象
 *
 */
public class Date01 {
    public static void main(String[] args) throws ParseException {
        //1.获取当前系统时间
        //2.这里的Date类是在java.util包
        //3.默认输出的日期格式是国外的方式，因此通常需要对格式进行转换
        //构造器一：Date():创建一个对应当前时间的Date对象
        Date d1 = new Date(); //获取当前系统时间
        System.out.println("当前日期="+d1.toString());//Wed Apr 12 20:29:46 CST 2023
        System.out.println(d1.getTime()); //毫秒数：1681302706936
      //实例化SimpleDateFormat：使用默认的构造器
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        String format2 = sdf1.format(d1);
        System.out.println("默认构造器："+format2);

        //1.创建SimpleDateFormat对象，可以指定相应的格式
        //2.这里的格式使用的字母是规定好，不能乱写
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format = sdf.format(d1); //format:将日期转换成指定格式的字符串
        System.out.println("当前日期="+format);
        //构造器二：创建指定毫秒数的Date对象
        Date d2 = new Date(9234567); //通过指定毫秒数得到时间
        System.out.println("d2="+d2.toString()); //获取某个时间对应的毫秒数
        SimpleDateFormat smd = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format1 = smd.format(d2);
        System.out.println("当前日期="+format1);
        //创建java.sql.Date对象
        java.sql.Date d3 = new java.sql.Date(55255555L);
        System.out.println(d3);//1970-01-01

        //1.可以把一个格式化的String转成对应的Date
        //2.得到Date仍然在输出时，还是按照国外的形式，如果希望指定格式输出，需要转换（使用SimpleDateFormat)
        //3.在把String -->Date,使用的sdf格式需要和你给的String的格式一样，否则会抛出转换异常。
        String s="1996年01月01日 10:20:30 星期一"; //格式必须和sdf上的格式一致
        Date parse = sdf.parse(s);
        System.out.println("parse="+parse);
        System.out.println("parse"+sdf.format(parse));
       //解析：要求字符串必须是符合SimpleDateFormat识别的格式（通过构造器参数体现)
        //否则，抛异常
        String s1="23-4-12 下午9:09";
        Date parse1 = sdf1.parse(s1);
        System.out.println("解析默认构造器"+parse1);
        //如何将java.util.Date转化为java.sql.Date对象
        //情况一：
      /*  java.sql.Date d4 = new java.sql.Date(558884L);
        java.sql.Date d5=(java.sql.Date)d4;*/
        //情况二：
        Date d6 = new Date();
        java.sql.Date d7= new java.sql.Date(d6.getTime());
    }
}

我们运行之后如下所示：

我们在api文档里面来查看SimpleDate：

我们通过练习来使用SimpleDateFormat:
练习一：

package com.ypl.data_;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 练习一：字符串“2020-09-08”转换为java.sql.Date
 */
public class Pratice {
    public static void main(String[] args) {
        String birth="2020-09-08";
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date = s1.parse(birth);
            System.out.println(date);
            java.sql.Date birthDate = new java.sql.Date(date.getTime());
            System.out.println(birthDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }


    }
}

运行之后如下所示：

练习二：

package com.ypl.data_;

import javax.xml.crypto.Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * "三天打渔两天晒网“ 1990-01-01  xxxx-xx-xx 打渔？ 晒网？
 * 举例：2020-09-08 ？ 总天数
 *
 * 总天数%5==1，2，3：打渔
 * 总天数%5==4，0：晒网
 * 总天数的计算？
 * 方式一：date2.getTime()-date1.getTime();  (1000*60*60*24)
 * 方式二：1990-01-01-->2019-12-31 -->求出整年。*365  2020-01-01-->2020-09-08
 */
public class Practice1 {
    public static void main(String[] args) throws Exception {
        //开始时间的毫秒数
        String s1="1990-01-01";
        SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = s2.parse(s1);
            System.out.println(parse);
            long t1 = parse.getTime();
            System.out.println("开始时间的毫秒数:"+t1);


        //结束时间的毫秒数
        String s3="2020-09-08";
        SimpleDateFormat s4 = new SimpleDateFormat("yyyy-MM-dd");
            Date parse1 = s4.parse(s3);
            System.out.println(parse1);
            long t2 = parse1.getTime();
            System.out.println("结束时间的毫秒数:"+t2);

            //时间相差为：
        long tc=t2-t1;
        System.out.println(tc);

        //转换为天数
        long td=tc/(1000*60*60*24)+1;
        System.out.println(td);

        //进行取模操作：
        if(td%5==1||td%5==2||td%5==3){
            System.out.println("打渔");
        }else if (td%5==4||td%5==0){
            System.out.println("晒网");
        }


    }
}

运行之后如下所示：

 aaaaaaaaaaaaaaaaaaa

(4)Calendar类（日历）

1.第二代日期类，主要就是Calendar类（日历）

2.Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

我们查看他的类图：

 我们发现Calendar的构造器是私有的：

我们查看他的方法：

 我们发现这些方法中有些是Calendar私有的。

 我们在去创建一个Calendar的时候是通过getInstance来获取的。

我们查看源码如下：

我们发现这两个构造方法都是私有的。

通过如下两个来获取Calendar:

  我们查看Calendar的字段如下所示：

我们查看他的内部类如下所示：
 我们的案例代码如下所示：

package com.ypl.data_;

import java.util.Calendar;

public class Calendar_ {
    public static void main(String[] args) {
//一、实例化
//方式一：创建其子类（GregorianCalendar)的对象
//方式二：调用其静态方法getInstance();
        //1.Calendar是一个抽象类，并且构造器是private
        //2.可以通过getInstance( )来获取实例
        //3.提供大量的方法和字段提供给程序员
        //4.Calendar没有提供对应的格式化的类，因此需要程序员自己组合来输出（灵活）
        Calendar c = Calendar.getInstance();//创建日历类对象 //比较简单，自由
        System.out.println("c="+c);
        //4.获取日历对象的某个日历字段
        System.out.println("年："+c.get(Calendar.YEAR));
        //这里为什么要+1，因为Calendar返回月时候，是按照 0 开始编号
        System.out.println("月:"+(c.get(Calendar.MONTH)+1));
        System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时："+c.get(Calendar.HOUR));
        System.out.println("分钟："+c.get(Calendar.MINUTE));
        System.out.println("秒："+c.get(Calendar.SECOND));
        //Calendar没有专门的格式化方法，所以需要程序员自己来组合显示
        System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");
    }
}

 我们运行之后如下所示：

以上显示的是12小时时间，我们修改如下为24小时：

package com.ypl.data_;

import java.util.Calendar;

public class Calendar_ {
    public static void main(String[] args) {
        //1.Calendar是一个抽象类，并且构造器是private
        //2.可以通过getInstance( )来获取实例
        //3.提供大量的方法和字段提供给程序员
        //4.Calendar没有提供对应的格式化的类，因此需要程序员自己组合来输出（灵活）
        //5.如果我们需要按照24小时进制来获取时间，Calendar.HOUR==改成==>Calendar.HOUR_OF_DAY
        Calendar c = Calendar.getInstance();//创建日历类对象 //比较简单，自由
        System.out.println("c="+c);
        //4.获取日历对象的某个日历字段
        System.out.println("年："+c.get(Calendar.YEAR));
        //这里为什么要+1，因为Calendar返回月时候，是按照 0 开始编号
        //获取星期时：周日是1，周二是2，，，周六是7
        System.out.println("月:"+(c.get(Calendar.MONTH)+1));
        System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时："+c.get(Calendar.HOUR_OF_DAY));
        System.out.println("分钟："+c.get(Calendar.MINUTE));
        System.out.println("秒："+c.get(Calendar.SECOND));
        //Calendar没有专门的格式化方法，所以需要程序员自己来组合显示
        System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");
    }
}

我们运行之后如下所示：

我们查看其他方法：

我们发现calendar是可变的（可变性）

package com.ypl.data_;

import java.util.Calendar;
import java.util.Date;

public class Ca {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        //常用方法：
        //get
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //set
        calendar.set(Calendar.DAY_OF_MONTH,22);
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        //add
        calendar.add(Calendar.DAY_OF_MONTH,3);
        int days1 = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days1);
        //减
        calendar.add(Calendar.DAY_OF_MONTH,-3);
        int days2 = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days2);
        //getTime Calendar(日历类）--->Date
        Date d = calendar.getTime();
        System.out.println(d);
        //setTime():Date--->Calendar
        Date date = new Date();
        calendar.setTime(date);
        int days3 = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days3);
    }
}

运行之后如下所示：

 （5）第三代日期类：LocalDate(日期/年月日）、LocalTime(时间/时分秒）、LocalDateTime(日期时间/年月日时分秒）JDK8加入

前面两代日期类的不足分析

JDK1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用了。而Calendar也存在问题是：

1.可变性：像日期和时间这样的类应该是不可变的。

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

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

4.此外，他们也不是线程安全的；不能处理闰秒等（每隔2天，多出1s)

偏移量体现：

package com.ypl.data_;

import java.util.Date;

public class Pianyi {
    public static void main(String[] args) {
        //偏移量
        Date date1 = new Date(2020,9,8);
        System.out.println(date1);
        Date date = new Date(2020-1900,9-1,8);
        System.out.println(date);
    }
}

LocalDate:只包含日期，可以获取日期字段

LocalTime只包含时间，可以获取时间字段

LocalDateTime:包含日期+时间，可以获取日期和时间字段

我们查看LocalDateTime的类图如下所示：

我们查看他的构造器：
 我们查看他的方法如下所示：

 我们查看他的基本获取如下所示：

package com.ypl.data_;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class LocalDate_ {
    public static void main(String[] args) {
        //第三代日期
        //1.使用now( )返回表示当前日期时间的对象
        LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now( ); //LocalTime.now( )
        System.out.println(ldt);
        System.out.println("年="+ldt.getYear());
        System.out.println("月="+ldt.getMonth());//英文日
        System.out.println("月="+ldt.getMonthValue());//中文月

        System.out.println("日="+ldt.getDayOfYear());//一年的第几天
        System.out.println("日="+ldt.getDayOfMonth());//一个月的第几天
        System.out.println("时="+ldt.getHour());
        System.out.println("分="+ldt.getMinute());
        System.out.println("秒="+ldt.getSecond());

        LocalDate now = LocalDate.now();//可以获取年月日
        System.out.println(now.getYear());
        LocalTime now1 = LocalTime.now();//可以获取时分秒
        System.out.println(now1.getHour());


    }
}

运行之后如下所示：

DateTimeFormatter格式化

我们进行格式化如下所示：

 DateTimeFormatter格式日期类，类似于SimpleDateFormat

我们在jdk1.8及其以后发现如下所示：

 我们实例如下所示：

package com.ypl.data_;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class LocalDate_ {
    public static void main(String[] args) {
        //第三代日期
        //1.使用now( )返回表示当前日期时间的对象
        LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now( ); //LocalTime.now( )
        System.out.println(ldt);

        //2.使用DateTimeFormatter对象来进行格式化
        //创建DateTimeFormatter对象
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH：mm：ss");
        String format = dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期="+format);




    }
}

我们运行之后如下所示：

 Instant时间戳，类似于Date，提供了一系列和Date类转换的方式

Instant -->Date:Date.form(instant);

Date--->Instant:date.toInstant():

我们查看他的类图如下所示：

 我们查看他的方法如下所示：

 我们设计的代码如下所示：

package com.ypl.data_;

import java.sql.Date;
import java.time.Instant;

public class Instant_ {
    public static void main(String[] args) {
       //1.通过静态方法now( )获取表示当前时间戳的对象
        Instant now = Instant.now();
        System.out.println(now);
        //2.通过from可以把Instant转成Date
      java.util.Date from = Date.from(now);
        System.out.println(from);
        //3.通过date的toInstant( )可以把date转成Instant对象
        Instant instant = from.toInstant();
         System.out.println(instant);
        
    }
}

我们运行之后如下所示：

第三代日期类更多方法：

1.LocalDateTime类

2.MonthDay类：检查重复事件

3.是否是闰年

4.增加日期的某个部分

5.使用plus方法测试增加时间的某个部分

6.使用minus方法测试查看一年前和一年后的日期

 我们设计的代码如下所示：
 

package com.ypl.data_;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class LocalDate1_ {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH：mm：ss");
        //提供 plus和minus方法可以对当前时间进行加或者减
        //看看890天后，是什么时候  把年月日-时分秒
        LocalDateTime localDateTime = now.plusDays(890);
        System.out.println("890天后="+dateTimeFormatter.format(localDateTime));

        //看看在3456分钟前是什么时候， 把年月日-时分秒输出
        LocalDateTime localDateTime1 = now.minusMinutes(3456);
        System.out.println("3456分钟前 日期="+dateTimeFormatter.format(localDateTime1));
    }
}

运行之后如下所示：