javaSE基础知识——day14 常用类 Math类、Randomlei类、System类、Date类、SimpleDateFormat转换类、Calender.getInstnce()类获取日期

BigInteger

Ｍath类：

public class MathDemo {
    public static void main(String[] args) {
        //Math 数学工具类
        //属性
        double pi = Math.PI;
        double e = Math.E;
        //方法
        double num = Math.random(); /*生成随机数 0-----1 之间*/
        //获取最值
        int max = Math.max(19, 20);
        int min = Math.min(20, 40);
        int max1 = Math.max(Math.max(19, 20), 100);
        //向上取整，向下取整
        double ceil = Math.ceil(1.9);
        double floor = Math.floor(1.9);
        //四舍五入
        long round = Math.round(1.48);
        System.out.println(round+"=====");
        //求一个几次幂
        double pow = Math.pow(2, 3);
        System.out.println(pow);
        //求平方根
        double sqrt = Math.sqrt(4);
        System.out.println(sqrt);
        //求一个数的立方根
        double pow2 = Math.pow(8, 1.0/3);
        System.out.println(pow2);

        //求一个数的绝对值
        System.out.println(Math.abs(-1));


        //static double cos ( double a)
        //返回角的三角余弦。

    }
}

Random类

案例一：

public class RandomDemo {
    public static void main(String[] args) {
        //生成随机数据的类
        // 此类的实例用于生成伪随机数流。此类使用 48 位的种子，
        Random random = new Random();
        //生成一些随机整数
       byte[] bytes= new byte[10];
        for (int i = 0; i < 100; i++) {
            //int num = random.nextInt(); //如果没有传入一个范围，生成的随机数就是int的范围
           //int num = random.nextInt(100); //范围就是 0-99 包含0和99
          //  int num = random.nextInt(100)+1;

          //  double num = random.nextDouble();
          //  boolean b = random.nextBoolean();
            //随机一些byte范围的数，填到这个数组中
            random.nextBytes(bytes);

            System.out.println(Arrays.toString(bytes));

        }



    }
}

种子：给定了种子，每次生成的随机数都是一样的
案例二：

public class RandomDemo2 {
    public static void main(String[] args) {
        //Random( long seed)
        //使用单个 long 种子创建一个新的随机数生成器。
        //给定了种子，每次生成的随机数都是一样的
        Random random = new Random(1L);
        for (int i = 0; i < 10; i++) {
            int i1 = random.nextInt(10);
            System.out.println(i1);
        }
    }
}

System类

A:System类的概述
System 类包含一些有用的类字段和方法。它不能被实例化。
成员变量 in(标准的输入流，对应设备是键盘) out （标准的输出流，对应的设备是屏幕）
public static void gc()//调用垃圾回收器
public static void exit(int status)//退出java虚拟机 0 为正常退出 非0为 异常退出
public static long currentTimeMillis()//获取当前时间的毫秒值

BigDecimal类

A:BigDecimal的概述
由于在运算的时候，float类型和double很容易丢失精度，演示案例。
所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

不可变的、任意精度的有符号十进制数。

B:构造方法
public BigDecimal(String val)
C:成员方法
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 取舍模式 比如四舍五入
D:案例演示
BigDecimal类的构造方法和成员方法使用

Date类

A:Date类的概述
类 Date 表示特定的瞬间，精确到毫秒。
B:构造方法
public Date()
public Date(long date) //把一个long类型的毫秒值转换成一个日期对象
C:成员方法
public long getTime(): 获取一个日期对象对象毫秒值
public void setTime(long time): 给一个日期对象设置上指定的毫秒值

案例1：

public class MyTest {
    public static void main(String[] args) {
       // 类 Date 表示特定的瞬间，精确到毫秒。
        Date date = new Date();
         //  Sun Jul 14 10:17:19 CST 2019
        System.out.println(date.toString()); //打印当前的日期
        //Date( long date)
        //分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

        Date date1 = new Date(0); //给计算机元年加上相应的时间量
        System.out.println(date1);
    }
}

案例二：

public class MyTest2 {
    public static void main(String[] args) {
        Date date = new Date();
        //获取当前系统的毫秒值
        long time = date.getTime();
        System.out.println(time);
        //获取当前系统的毫秒值
        //long l = System.currentTimeMillis();
        //System.out.println(l);


        Date date1 = new Date();
        date1.setTime(1000*60*60); //给计算机元年设置相应的时间量
        System.out.println(date1);


        Date date2 = new Date(1000 * 60 * 60);


    }
}

案例三：

public class MyTest3 {
    public static void main(String[] args) {
        Date date = new Date();
        int year = date.getYear();
        int month = date.getMonth();
        int day = date.getDay();
        System.out.println(year);
        System.out.println(month);
        System.out.println(day);

        //月份从0开始数
    }
}

案例三：
long-------Dat之间的换

public class MyTest4 {
    //long-------日期Date
    public static void main(String[] args) {
        long time = 1000 * 60 * 60;
        Date date = new Date(time);

        new Date().setTime(time);

        //Date------1000
        Date date1 = new Date();
        long time1 = date1.getTime();

    }
}

SimpleDateFormat类实现String-------Date的相互转换

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):Date------String
public Date parse(String dateStr): String -----Date
案例一：

import java.text.SimpleDateFormat;
import java.util.Date;
public class MyTest {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.toString());
        //格式化日期的类型
        //使用空参创建SimpleDateFormat创建对象，那么使用的是默认的格式来格式化日期 19-5-2 上午10:56
        SimpleDateFormat format = new SimpleDateFormat();
        //格式化日期，返回的是格式化后的日期字符串
        String format1 = format.format(date);
        System.out.println(format1);
        //我们可以指定格式来格式化日期

        //规则的定义
        //
        //y 年
        //M 月
        //d 天
        //H 时
        //m 分
        //s 秒
        //E 星期几
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E w W F");

        String format3 = format2.format(date);
        System.out.println(format3);
	
		//Mon May 20 17:46:28 GMT+08:00 2019
		//19-5-20 下午5:46
		//2019-05-20 17:46:28 星期一 21 4 3

    }
}

案例二：

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

public class MyTest2 {
    public static void main(String[] args) throws ParseException {
        String timeStr = "2018-01-01 15:30:30";  //Date

        //注意解析时：日期字符串和SimpleDateFormat("yyyy-MM-dd HH:mm:ss");它里面的格式要对应，否则解析失败
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = format.parse(timeStr);
        System.out.println(date);    //Mon Jan 01 15:30:30 GMT+08:00 2018
    }
}

案例三：
你在这个世界上生活了多少天？

package day201907015.zhengzereview;

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

/**
 * @description: 你来到这个世界上多少天了
 * @author: @李小白
 * @create: 2019-07-15 13:58
 */
public class Demo02 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);//键盘录入
        System.out.println("输入您的姓名");
        String name = sc.nextLine();
        System.out.println("请输入您的出生年月日");
        String str = sc.nextLine();
        //调Date---String 转换方法
        Date date = StrDemo02.parseDate(str, "yyyy-MM-dd");
        //输出我的毫秒值
        long my = date.getTime();
        //输出系统当前的毫秒值
        long system = System.currentTimeMillis();

        long time=(system-my);
        long millus=time/1000;
        long mines=time/1000/60;
        long hour=time/1000/60/60;
        long real=time/1000/60/60/24;
        long year=time/1000/60/60/24/365;
        System.out.println(name+"来到这个世界上"+millus+"秒"+mines+"分"+hour+"小时"+real+"天"+year+"年");
    }
}

package day201907015.zhengzereview;

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

/**
 * @description:
 * @author: @李小白
 * @create: 2019-07-15 14:02
 */
public class StrDemo02 {
    //String---Date
    public static Date parseDate(String name, String forme) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(forme);
        Date parse = simpleDateFormat.parse(name);
        return parse;
    }
    //Date---String

    public static String formatDate(String forme){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(forme);
        String format = simpleDateFormat.format(new Date());
        return format;
    }
}

案例四：

import java.time.LocalDate;
import java.time.Period;
public class MyTest3 {
    public static void main(String[] args) {
        //JDK1.8 之后，提供了一套全新的时间日期API 也推荐你使用JDK1.8所提供的

        //_常见对象(你来到这个世界多少天案例) (掌握)
        LocalDate start = LocalDate.of(1998, 5, 13);

        LocalDate now = LocalDate.now();

        //算出两个日期的间隔
        Period between = Period.between(start, now);
        int years = between.getYears();
        int months = between.getMonths();
        int days = between.getDays();

        System.out.println("你现在"+years+"岁 零"+months+"月 零"+days+"天");


    }
}

Calendar类

A:Calendar类的概述
Calendar 类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象
它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR
等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
B:成员方法
public static Calendar getInstance() 使用默认时区和语言环境获得一个日历对象
public int get(int field) 获得给定日历字段对应的值 field通过Calendar提供的字段来拿

案例一：

package org.westos.demo4;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
public class MyTest {
    public static void main(String[] args) {
        //GregorianCalendar
        Calendar instance = Calendar.getInstance();
       // System.out.println(instance.toString());
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH);
        int day = instance.get(Calendar.DAY_OF_MONTH);

        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(instance.get(Calendar.HOUR_OF_DAY));
        System.out.println(instance.get(Calendar.MINUTE));
        System.out.println(instance.get(Calendar.SECOND));
        //2019
		//4
		//20
		//18
		//6
		//26


    }
}

常见对象(Calendar类的add()和set()方法)
案例二：

import java.util.Calendar;

public class MyTest2 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();
        //给相应的日期字段，加上或减去相应的时间量
        instance.add(Calendar.YEAR,1);
        instance.add(Calendar.MONTH, 1);
        instance.add(Calendar.DAY_OF_MONTH,-1);

        int i = instance.get(Calendar.YEAR);
        int i1 = instance.get(Calendar.MONTH);
        int i2 = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
    }
}

案例三：

import java.util.Calendar;

public class MyTest3 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();
        //可以设置年月日，时分秒 给某个日历字段设置值
        instance.set(Calendar.YEAR,2010);
        instance.set(Calendar.MONTH,10);
        int i = instance.get(Calendar.YEAR);
        System.out.println(i);
        System.out.println(instance.get(Calendar.MONTH));
    }
}

案例四：

//A:
//案例演示
//需求：键盘录入任意一个年份，获取任意一年的二月有多少天
``
package day20190714.study02;

import java.util.Calendar;
import java.util.Scanner;

/**
 * @description: 输出任意一年中2月有多少天
 * @author: @李小白
 * @create: 2019-07-14 14:26
 */
public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入任意一个年份");
        int year = sc.nextInt();

        if (year%4==0&&year%100!=0||year%400==0) {
            System.out.println("这是瑞年");
        }

        Calendar instance = Calendar.getInstance();
        instance.set(year,2,1);//先输出3月的第一天
        instance.add(Calendar.DAY_OF_MONTH,-1);//减1输出2月的最后一天
        int i = instance.get(Calendar.DAY_OF_MONTH);//输出这个月
        System.out.println(i);

    }
}

BigInteger概述 可以让超过Integer范围内的数据进行运算

构造方法
public BigInteger(String val)
成员方法
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)

示例

 BigInteger bi2=new BigInteger("2");
        
System.out.println(bi1.add(bi2));   //+
System.out.println(bi1.subtract(bi2));   //-
System.out.println(bi1.multiply(bi2));   //*
System.out.println(bi1.divide(bi2));    //(除)
        
 BigInteger[] arr=bi1.divideAndRemainder(bi2);    //取除数和余数
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

案例

public class MyTest2 {
    public static void main(String[] args) {
        int a = Integer.MAX_VALUE;
        int b = Integer.MAX_VALUE;

        System.out.println(a*b);
        //BigInteger概述 可以让超过Integer范围内的数据进行运算
        BigInteger bigInteger1 = new BigInteger(String.valueOf(a));

        BigInteger bigInteger2 = new BigInteger(String.valueOf(b));

        BigInteger multiply = bigInteger1.multiply(bigInteger2);
        System.out.println(multiply.toString());
    }
}
    }
}