Java中常用类的学习（Math类、Random类、System类、BigDecimal类、Date类、SimpleDateFormat类、Calendar类、BigInteger类）

1、Math类

Math类概述:
查API可以发现，该类是一个工具类，因此它的很多方法和字段都是静态的，我们只需要使用类名就可以调用。Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

成员变量:
public static final double E : 自然底数
public static final double PI: 圆周率
成员方法:
public static int abs(int a) 取绝对值
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static int max(int a,int b) 获取最大值
public static int min(int a, int b) 获取最小值
public static double pow(double a,double b) 获取a的b次幂
public static double random() 获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
public static int round(float a) 四舍五入
public static double sqrt(double a)获取正平方根

package org.westos.demo2;

public class MyTest1
{
    public static void main(String[] args)
    {
        System.out.println("计算机中存储的指数E的值为："+Math.E);
        //2.718281828459045
        System.out.println("计算机中存储的圆周率PI的值为："+Math.PI);
        //3.141592653589793
        System.out.println("取完绝对值之后为："+Math.abs(-23));//23
        System.out.println("向上取整之后为："+Math.ceil(2.7));//3.0
        System.out.println("向上取整之后为："+Math.ceil(2.3));//3.0
        System.out.println("向下取整之后为："+Math.floor(2.7));//2.0
        System.out.println("向下取整之后为："+Math.floor(2.3));//2.0
        System.out.println("获取的最大值为："+Math.max(2, 3));//3
        System.out.println("获取的最小值为："+Math.min(2, 3));//2
        System.out.println("计算的结果为："+Math.pow(2, 3));//8
        for (int i = 0; i < 5; i++)
        {
            System.out.println("第"+i+"个随机数为："+Math.random());
            //获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
        }
        /*第0个随机数为：0.37918695090078447
        第1个随机数为：0.14198003556757177
        第2个随机数为：0.6653933397189188
        第3个随机数为：0.162202597542782
        第4个随机数为：0.03156686246058149*/
        System.out.println("四舍五入之后的结果为："+Math.round(2.59));//3
        System.out.println("获取的平方根为："+Math.sqrt(5));//2.23606797749979
    }
}

2、Random类

此类在java.util包下，产生的实例用于生成伪随机数流。

无参构造Random() ：创建一个新的随机数生成器
有参构造Random(long seed) ：使用单个 long 种子创建一个新的随机数生成器
两个构造的区别在于：无参构造程序再次运行时产生的随机数会发生变化，而程序再次运行时有参构造产生的随机数不会发生变化

package org.westos.demo2;
import java.util.Arrays;
import java.util.Random;
public class MyTest2
{
    public static void main(String[] args)
    {
        Random r=new Random();//无参构造
        byte[] b=new byte[3];
        for (int i = 0; i < 5; i++)
        {
            System.out.println(r.nextInt());//不给这个方法参数，就会产生int范围内的任何随机数
            System.out.println(r.nextInt(100));//给一个数字，会输出0-99范围内的随机数
            System.out.println(r.nextDouble());//产生双精度类型的浮点数,范围在0-1
            System.out.println(r.nextBoolean());//产生布尔类型的随机数
            r.nextBytes(b);//产生byte随机数组
            System.out.println(Arrays.toString(b));//输出数组中的数
        }
        /*第一次循环后产生的随机数：
        -1418964434
        89
        0.8799111884264906
        true
        [105, -110, -82]*/
    }
}

package org.westos.demo2;
import java.util.Arrays;
import java.util.Random;
public class Mytest3
{
    public static void main(String[] args)
    {
        Random r=new Random(1L);//查看API文档，发现有参构造需要一个long类型的种子，给一个long类型的数据
        byte[] b=new byte[3];
        for (int i = 0; i < 5; i++)
        {
            System.out.println(r.nextInt());//不给这个方法参数，就会产生int范围内的任何随机数
            System.out.println(r.nextInt(100));//给一个数字，会输出0-99范围内的随机数
            System.out.println(r.nextDouble());//产生双精度类型的浮点数
            System.out.println(r.nextBoolean());//产生布尔类型的随机数
            r.nextBytes(b);//产生byte随机数组
            System.out.println(Arrays.toString(b));//输出数组中的数
        }
        /*第一次循环后产生的随机数：
        -1155869325
        88
        0.41008081149220166
        false
        [-16, -72, 70]
        再次运行程序，第一次循环产生的随机数仍然是上面的数据
        */
    }
}

3、System类

System类的概述：
System 类在java.lang包下，包含一些有用的类字段和方法，它不能被实例化。 查看API，发现该类是一个被final修饰的类，不能被继承。

成员字段：
static PrintStream err “标准”错误输出流
static InputStream in “标准”输入流(此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源)
static PrintStream out “标准”输出流(此流已打开并准备接受输出数据。通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。)
成员方法：
public static void gc() 调用垃圾回收器(调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间)
public static void exit(int status) 退出java虚拟机，0为正常退出，非0为异常退出
public static long currentTimeMillis() 获取当前时间的毫秒值

package org.westos.demo2;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;
public class MyTest4
{
    public static void main(String[] args)
    {
        System.err.println("标准错误输出流");//输出字体为红色

        //InputStream类是一个抽象类，在IO流处会涉及到这块知识，为什么Scanner类需要这个？
        //打开API，就会发现它是一个“标准”输入流，此流打开并准备提供输入数据
        InputStream in = System.in;
        Scanner sc=new Scanner(in);

        PrintStream out = System.out;
        out.println("标准输出流");
        //我们平时采用的是链式编程，与上面两行代码效果相同
        System.out.println("相同效果的链式编程");

        System.gc();//运行垃圾回收器，实际上，JVM有自己的一套垃圾回收算法，
        // 一般来说我们不干预，也干预不到，这个语句只是为了催促垃圾回收器，尽快回收垃圾

        long l1 = System.currentTimeMillis();
        //获取系统当前毫秒值，这个时间以计算机元年为参照计算
        //一般来说，我们用这条语句可以判断程序执行循环所需时间
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long l2 = System.currentTimeMillis();
        long l = l2 - l1;
        System.out.println("执行这个循环所花费的时间为："+l+"毫秒");//160毫秒

        System.exit(0);//给0正常退出，非0为异常退出，表示退出JVM，程序执行到这里，下面的语句不会执行
    }
}

4、BigDecimal类

由于在运算的时候，float类型和double很容易丢失精度，所以为了能精确的表示、计算浮点数，Java提供了BigDecimal类。如果你觉得 double 类不能满足你对数字的要求，或者做银行类的项目时，需要用到这个数据类型，BigDecimal 类在 java.Math 包下。

常用的构造方法：
public BigDecimal(String val)
常用的成员方法：
public BigDecimal add(BigDecimal augend)//加
public BigDecimal subtract(BigDecimal subtrahend)//减
public BigDecimal multiply(BigDecimal multiplicand)//乘
public BigDecimal divide(BigDecimal divisor)//除法
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//scale 小数点后面保留几位，roundingMode 取舍模式 比如四舍五入，以下是一些取舍模式：

package org.westos.demo2;
import java.math.BigDecimal;
public class MyTest5
{
    public static void main(String[] args)
    {
        BigDecimal a=new BigDecimal(12);
        //查看API，发现该类不存在无参构造，这意味在new对象时，必须要给定一个参数
        BigDecimal b=new BigDecimal(53);
        System.out.println(a);//12
        System.out.println(b);//53
        BigDecimal addNum = a.add(b);
        System.out.println("两数相加的结果为："+addNum);//65
        BigDecimal subNum = a.subtract(b);
        System.out.println("两数相减的结果为："+subNum);//-41
        BigDecimal mulNum = a.multiply(b);
        System.out.println("两数相乘的结果为："+mulNum);//636

        BigDecimal c=new BigDecimal(24);
        BigDecimal divNum = c.divide(a);
        System.out.println("两数相除之后的结果为："+divNum);//2

        //BigDecimal divNum1 = b.divide(a);
        BigDecimal divNum1 = b.divide(a,BigDecimal.ROUND_CEILING);//接近正无穷大的舍入模式,5
        System.out.println("两数相除后的结果为："+divNum1);
        //程序报错：Exception in thread "main" java.lang.ArithmeticException:
        //Non-terminating decimal expansion; no exact representable decimal result.
        //如果不能整除，你没有给定范围就会报算术异常的错误
    }
}

5、Date类

类 Date 表示特定的瞬间，精确到毫秒，在JDK1.0时就存在了。

常用的构造方法：
Date() ：
分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）
Date(int year, int month, int date) :
已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date) 或 GregorianCalendar(year + 1900, month, date) 取代
Date(long date) :
分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
常用的成员方法：
public long getTime(): 获取一个日期对象对象毫秒值
public void setTime(long time): 给一个日期对象设置上指定的毫秒值，例：date.setTime(1000 * 60 * 60) ;

package org.westos.demo2;
import java.util.Date;
public class MyTest6
{
    public static void main(String[] args)
    {
        Date date=new Date();//分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）
        System.out.println(date);//Sun Jan 19 12:24:57 CST 2020
        Date date1=new Date(0);//对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数
        System.out.println(date1);//Thu Jan 01 08:00:00 CST 1970计算机元年时中国的时间，可以改变参数给计算机元年加上相应的时间

        long time = date.getTime();//获取一个日期对象对象毫秒值
        System.out.println(time);//1579408241101

        date.setTime(1000 * 60 * 60);//	给一个日期对象设置上指定的毫秒值
        System.out.println(date);//Thu Jan 01 09:00:00 CST 1970

        Date date2=new Date();
        System.out.println(date2.getMonth());//划横线的方法代表已经过时，注意月份是从0开始数，0
        System.out.println(date2.getDay());//0
        System.out.println(date2.getHours());//12
        System.out.println(date2.getMinutes());//35
        System.out.println(date2.getSeconds());//30
    }
}

Long类型数据和Date类型数据的转换：

package org.westos.demo2;
import java.util.Date;
public class MyTest7
{
    public static void main(String[] args)
    {
        //long----->Date
        long l=1000*60*60;
        Date date=new Date(l);
        System.out.println(date);//方法一,Thu Jan 01 09:00:00 CST 1970

        new Date().setTime(l);//方法2

        //Date----->long
        Date date1=new Date();
        long l2=date1.getTime();
        System.out.println(l2);//1579408880500,以毫秒为单位
    }
}

6、SimpleDateFormat类

SimpleDateFormat 类是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

构造方法:
public SimpleDateFormat():使用默认的模式来创建一个SimpleDateFormat对象
public SimpleDateFormat(String pattern):使用指定的模式（规则比如yyyy:MM:dd HH:mm:ss）来创建一个SimpleDateFormat对象
规则的定义:
y 年
M 月
d 天
H 时
m 分
s 秒
成员方法:
public String format(Date date): 把一个日期对象格式化成一个字符串
public Date parse(String dateStr): 把一个日期字符串解析成一个日期对象 注意要以指定格式解析

package org.westos.demo2;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyTest8
{
    public static void main(String[] args) throws ParseException {
        /*
        成员方法:
        public String format(Date date): 	把一个日期对象格式化成一个字符串
        public Date parse(String dateStr):	把一个日期字符串解析成一个日期对象 注意要以指定格式解析*/
        Date date=new Date();
        SimpleDateFormat s=new SimpleDateFormat();//采用默认格式对日期格式化
        String str=s.format(date);
        System.out.println("默认的格式输出的字符串为："+str);//20-1-19 下午1:31

        //我们可以根据自己需要来指定日期格式
        SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str1=s1.format(date);
        System.out.println("自定义的格式输出的字符串为："+str1);//2020-01-19 13:34:42

        String str2="2019-12-12 12:12:12";
        SimpleDateFormat s2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //这个格式必须与你要解析的Date类型数据格式一致，否则会报解析异常的错误
        Date parse = s2.parse(str2);
        System.out.println("解析后的字符串为："+parse);//Thu Dec 12 12:12:12 CST 2019
    }
}

案例：算一下你来到这个世界多少天?

测试类：
package org.westos.demo;
import java.sql.SQLOutput;
import java.text.ParseException;
import java.util.Date;
import java.util.Scanner;
public class MyTest
{
    public static void main(String[] args) throws ParseException
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你出生的年月日：(格式：1990-01-01)");
        //键盘录入生日字符串
        String s=sc.nextLine();//2001-09-01
        //将字符串解析成为一个日期对象
        Date bir = DateUtils.parseStringDate(s, "yyyy-MM-dd");
        //获取生日的毫秒值
        long birTime = bir.getTime();
        //获取当前日期的毫秒值
        long nowTime = System.currentTimeMillis();
        //获取差值
        long sub=nowTime-birTime;
        long l = sub / 1000 / 60 / 60 / 24;
        System.out.println("你来到这个世界已经"+l+"天了");//6714
    }
}
工具类：
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtils
{
    private DateUtils(){}//私有化构造参数
    //将日期格式成为字符串
    public static String formatDate(String format)
    {
        SimpleDateFormat s=new SimpleDateFormat(format);
        String str = s.format(new Date());
        return str;
    }
    //将日期字符串变成日期对象
    public static Date parseStringDate(String dateStr,String format) throws ParseException
    {
        SimpleDateFormat s=new SimpleDateFormat(format);
        Date date=s.parse(dateStr);
        return date;
    }
}

7、Calendar类

许多Date类重的过时方法都在该类里面有对应的相同功能的方法，Calendar 类是一个抽象类，不能直接new对象，可以通过它的一个静态成员方法getInstance()来获取他的对象。它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

成员方法:
public static Calendar getInstance() 使用默认时区和语言环境获得一个日历对象
public int get(int field) 获得给定日历字段对应的值 field通过Calendar提供的字段来拿
public abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量
public final void set(int year, int month, int date) 将给定的日历字段设置为给定值

package org.westos.demo;
import java.util.Calendar;
public class MyTest2
{
    public static void main(String[] args)
    {
        Calendar c = Calendar.getInstance();
        System.out.println(c.getTime());//Sun Jan 19 14:09:33 CST 2020
        int i = c.get(Calendar.YEAR);//静态字段，值为1
        System.out.println(i);//2020
        c.add(Calendar.YEAR,1);//给相应的日历字段，加上或减去相应的量
        c.set(2050,01,01);//设置相应的时间
        System.out.println(c.getTime());//Tue Feb 01 14:09:33 CST 2050
    }
}

键盘录入任意一个年份，获取任意一年的二月有多少天:

package org.westos.demo;
import java.util.Calendar;
import java.util.Scanner;
public class Calendar类
{
    public static void main(String[] args)
    {
        //键盘录入一个年份
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入年份：");//2008
        int year=sc.nextInt();
        //创建一个Calendar对象
        Calendar c=Calendar.getInstance();
        //把这个Calendar的时间设置为录入的年的3.1号
        //set(int year, int month, int date)
        //设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
        c.set(year,2,1);//注意，这里的2月代表3月,因为计算机里面月份是0-11
        c.add(Calendar.DAY_OF_MONTH,-1);//向前推算一天
        System.out.println(c.get(Calendar.DAY_OF_MONTH));//输出当前月份的天数，29
    }
}

8、BigInteger类

该类可以让超过Integer范围内的数据进行运算

package org.westos.demo;
import java.math.BigInteger;
import java.util.Arrays;
public class MyTest3
{
    public static void main(String[] args)
    {
        //构造方法
        BigInteger b1=new BigInteger("100");
        BigInteger b2=new BigInteger("200");
        System.out.println(b1);//100
        //成员方法
        System.out.println(b1.add(b2));//300--加
        System.out.println(b1.subtract(b2));//-100--减
        System.out.println(b1.multiply(b2));//20000--乘
        System.out.println(b1.divide(b2));//0--除
        BigInteger[] b3 = b1.divideAndRemainder(b2);
        //返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
        System.out.println(Arrays.toString(b3));//[0,100]
    }
}