Java 常用類

記錄一些Java 學(xué)習(xí)使用, 經(jīng)常使用類進(jìn)行總結(jié).. 這個文章感覺還是很有必要的 后面會常總結(jié)擴展...

String字符串相關(guān)的類

String Java.lang包

在這里插入圖片描述

• String是一個final類，代表不可變的字符序列
• 字符串是常量，用雙引號引起來表示。它們的值： 在創(chuàng)建之后不能更改
• String對象的字符內(nèi)容是存儲在一個字符數(shù)組value[]中的 ??
• 實現(xiàn)了 序列化 Comparable比較器 CharSequence 接口

String對象的創(chuàng)建：

子面量定義方式; 
    String s = "Hello World";   就是我們常用的方式...    
    
String代表不可變的字符序列,簡稱不可變性:
    在不new String("");           情況直接賦值相同值String類型對象,==比較是相同的;
    
     String a = "abc";  
     String b = "abc";
     boolean isok = (a==b);     結(jié)果為true;(==比對象比地址)  
原因：
    Java首次通過字面量方式聲明給一個字符串賦值時,會將字符串值聲明在: "Jvm方法區(qū)中常量池里,并把地址賦值給,?？臻g中的String對象上;"
    當(dāng)又一個String對象以字面量的方式賦同樣的值,它會直接引用相同的地址值;
    所以: "字面量賦值相同的String對象值 == 比較值相同結(jié)果為: true" (其實就是地址相同;
String不可變性:
    當(dāng)對字符串的值,重新賦值/拼接時,常量池中會出現(xiàn)你新賦值的一個空間字符串,需要重新指定常量池的地址值;而不是在改變原先空間的值;    

String s =  new String();
    new創(chuàng)建一個空字符串,相當(dāng)于底層new char[0];
    在堆空間創(chuàng)建出,空間存儲值,并把地址復(fù)制給,棧空間的對象引用;
    所以：
        String s = new String("s"); 
        String s1 = new String("s");
        boolean isok = (s==s1);         結(jié)果為 false
        對象指向的是堆空間的地址,new一個就產(chǎn)生一個...所以兩個new對象的地址永遠(yuǎn)不會true;
        但因為String值是存放在 常量池中的...所以其實真實情況是: "對象?！赶?gt; 堆地址 ——指向> 方法區(qū)"  

String的內(nèi)存解析：

首先我們要知道：Java創(chuàng)建對象

• JVM 里面有兩個用于存儲對象的空間 堆 棧
  堆： 存放所有new出來的對象
  棧： 存放基本類型的變量數(shù)據(jù)和對象的引用 對象本身不存放在棧中，而是存放在：堆 或 常量池; 引用類型棧對象只指向堆的地址~
  所以： new a 和 new b 程序在堆空間開啟了兩個地址，a b指向的堆地址不同 a==b ==比較地址返回 false
• 首先對于對象引用類型，程序每 new 一次的操作, 都會在JVM的堆空間中開辟一個內(nèi)存空間...

字面量方式賦值：

在這里插入圖片描述

在這里插入圖片描述

String類的常用方法();

這里就不一一舉例了，使用多了自然就會用了...

int         .length();          //返回字符串長度;
char[]      .toCharArray();     //String 與 char[]數(shù)組轉(zhuǎn)換; 
                                //char[]數(shù)組轉(zhuǎn)換成String  String str = new String(char[]);
                                
byte[]      .getBytes();        //String 與 byte[]數(shù)組轉(zhuǎn)換; byte類型值是數(shù)值類型的哦; a對應(yīng)97... 
                                注意中文: 分為一個/多個字節(jié),注意編碼格式; .getBytes();使用編輯器默認(rèn)編碼格式,可以通過.getBytes("utf-8");指定編碼格式; 
                                一個中文utf-8是3個字節(jié); GBK是2個字節(jié);

boolean     .isEmpty();         //判斷字符串是否是否是空字符; 
                                str.length()==0; 空true 則false
                                
boolean     .startWith(str);    //判斷當(dāng)前字符串是否以 str開頭是true則false 區(qū)分大小寫;
boolean     .endsWith(str);     //判斷當(dāng)前字符串是否以 str結(jié)尾是true則false 區(qū)分大小寫;

boolean     .contains();        //該方法判斷字符串中是否有指定字符內(nèi)容,
                                有true 無則false; 
                                eg: ABCD.conntains("ABC"); true; 
                                
int         .compareTo(String); //比較字符串大小;可進(jìn)行字符串排序;  
                                str.compareTo(str1); 一個給比較內(nèi)部值 負(fù)數(shù)str小,正數(shù)str大 0str一樣大等于str1;
                                
char        .charAt(int);       //獲取指定位置的字符; 
                                注意數(shù)組越界 "String歸根結(jié)底是一個 char[] 字符數(shù)組！"
                                
String      .replace("1","2");  //替換將字符串 
                                指定位置1字符/字符串,替換為2字符/字符串;
                                
boolean     .equals(String);    //比較字符串值是否一致 String 
                                "String重寫了Object類的equals(Objetc o)方法;"
                                
String      .toLowerCase();     //轉(zhuǎn)換 字符串 中英文字母 為小寫; 
                                返回字符串小寫形式,不影響堆/常量池
String      .toUpperCase();     //轉(zhuǎn)換 字符串 中英文字母 為大寫; 
                                返回字符串大寫形式,不影響堆/常量池
String      .concat();          //字符串1 .concat(字符串2); 
                                將2內(nèi)容追加在 1后面返回字符串; 也可以用'+' 拼接但效率低下;  
                                                                        
String      .trim();            返回一個不含空格的字符串;將字符串中所有空格取消;
int         .indexof('');       從頭開始搜索  獲取字符在字符串中的位置:
                                下標(biāo) 0開始 如果沒有 該字符返回 -1;   //如果參數(shù)是字符串以第一個字符為準(zhǔn)
                                
int         .lastIndexof('');   從后搜索第一個符合指定字符的位置 0開始沒有返回 -1;    //如果參數(shù) 是 字符串 以第一個 字符為準(zhǔn)
String      .Substring(int);        //提取從索引位置開始到后面所有的 字符串 返回;
String      .Substring(int1,int2);  //提取范圍內(nèi)字符串;
String[]    .spilt(String,int);     //拆分:
                                    根據(jù) String 字符為拆分 字符進(jìn)行拆分 返回 拆分后字符串?dāng)?shù)組[] 如果不指定 String 則 按 每個單字符 返回 數(shù)組;
                                    int 用來限制返回數(shù)組中元素個數(shù); "可選,默認(rèn)即不限制返回String[] 數(shù)組！";
                                    還可以是 正則表達(dá)式: |表示,或: str.spilt(",|."); 根據(jù) 逗號 或 句號 拆分!

StringBuffer

StringBuffer:

• 我們都知道，String類，并不適合頻繁的拼接， 每次拼接，其實是在JVM 方法區(qū)中有重復(fù)創(chuàng)建一個 字符常量數(shù)組！
• Java.lang.StringBuffer代表 可變的字符序列
  即，可以動態(tài)的拼接String 而不會開辟新的空間消耗內(nèi)存！
• 很多方法與String相同，作為參數(shù)傳遞時，方法內(nèi)部可以改變值。

創(chuàng)建：

StringBuffer類不同于String，其對象必須使用構(gòu)造器生成 有三個構(gòu)造器

• StringBuffer() 初始容量為16的字符串緩沖區(qū)
  本質(zhì)上StringBuffer 底層也是一個 字符數(shù)組，但不是常量數(shù)組長度可以動態(tài)改變的 默認(rèn)長度16
• StringBuffer(int size) 構(gòu)造指定容量的字符串緩沖區(qū)
• StringBuffer(String str) 將內(nèi)容初始化為指定字符串內(nèi)容 String s = new String("我喜歡學(xué)習(xí)");
• 在這里插入圖片描述

StringBuffer類的常用方法:

StringBuffer s = new StringBuffer();             //聲明一個空 StringBuffer對象;底層相當(dāng)于 new char[16];
StringBuffer s = new StringBuffer("ABC");        //聲明一個字符串 "ABC", 底層相當(dāng)于 new char["abc".length()+16];
總而言之：
    就是會,預(yù)存多幾個位置,供添加,如果還是超過了16,放心不會越界,反而它還會變大.自動擴容原長度*2...哈哈.
    注意的是 s.length(); 長度還是你本身的字符長度....

StringBuffer        .toString();                                //將StringBuffer 類型字符串 轉(zhuǎn)換為String 類型對象返回; Object類方法 一些寫類重寫了其方法(自定義類也可以重其方法);
StringBuffer        .append(String);                            //拼接指定字符串效率高..在char[]數(shù)組后添加..
StringBuffer        .insert(int位置,參數(shù));                      //在字符串指定位置 int 中插入?yún)?shù); 參數(shù)可以實 String 任何類型....;
StringBuffer        .delete(int start,int end);                 //刪除指定位置的內(nèi)容
StringBuffer        .replace(int start, int end, String str)；   //把[start,end)位置替換為str 
StringBuffer        .reverse();                                 //把當(dāng)前字符串逆轉(zhuǎn)！

StringBuilder

StringBuilder 和 StringBuffer 非常類似，均代表可變的字符序列，而且 提供相關(guān)功能的方法也一樣

總結(jié)：

String、StringBuffer、StringBuilder

• 三者都是操作字符串的一種類：
• String(JDK1.0)：不可變字符序列
• StringBuffer(JDK1.0)：可變字符序列、效率低、線程安全
• StringBuilder(JDK 5.0)：可變字符序列、效率高、線程不安全

三者執(zhí)行效率：

• String < StringBuffer < StringBuilder

注意：
作為參數(shù)傳遞的話，方法內(nèi)部String不會改變其值，StringBuffer和StringBuilder 會改變其值
String 是一種特殊的 引用類型, StringBuffer 和 StringBuilder 相當(dāng)于還是一種 引用類型的對字符串操作的一種類！

JDK8 之前的日期時間 API

世界時間：

時間是一個非常抽象的概念，多少年來，吸引著無數(shù)科學(xué)家、物理學(xué)家、甚至哲學(xué)家花費畢生精力去解釋時間的本質(zhì)是什么

• 這里我們不探討高深莫測的學(xué)術(shù)知識，只把目光放聚焦在計算機這個很小的范疇內(nèi)。
• 具體可以了解這里(大佬~)

計算世界時間的主要標(biāo)準(zhǔn):

UTC Coordinated Universal Time

• 世界標(biāo)準(zhǔn)時間：
• 協(xié)調(diào)世界時是以原子時秒長為基礎(chǔ)，國際原子時的準(zhǔn)確度為每日數(shù)納秒，原子鐘 現(xiàn)在我們使用的互聯(lián)網(wǎng)就采用該計時標(biāo)準(zhǔn)
• 經(jīng)嚴(yán)謹(jǐn)計算得到的時間，精確到秒，誤差在0.9s以內(nèi)， 是比GMT更為精確的世界時間

GMT Greenwich Mean Time

• 格林威治時間
• 英國倫敦格林威治定為0°經(jīng)線開始的地方，地球每15°經(jīng)度 被分為一個時區(qū)，共分為24個時區(qū)，相鄰時區(qū)相差一小時
  中國北京位于東八區(qū)，GMT時間比北京時間慢8小時
• 格林尼治標(biāo)準(zhǔn)時間的正午是指當(dāng)太陽橫穿格林尼治子午線時（也就是在格林尼治上空最高點時, 時間

CST Central Standard Time

• 中亞時間 中國: 北京時間~
• 四個不同時區(qū)的縮寫：
  Central Standard Time (USA) UTC-6:00 美國標(biāo)準(zhǔn)時間
  Central Standard Time (Australia) UTC+9:30 澳大利亞標(biāo)準(zhǔn)時間
  China Standard Time UTC+8:00 中國標(biāo)準(zhǔn)時間
  Cuba Standard Time UTC-4:00 古巴標(biāo)準(zhǔn)時間

在Java8之前時間API：

在這里插入圖片描述

• java.util.Date:表示Java中的日期，但是能夠操作到時間級別，
  如今這個類中的很多方法都已經(jīng)被廢棄，不建議使用；
  Date主要負(fù)責(zé)存儲一個絕對時間 并對兩邊提供操作接口

• java.sql.Date:表示數(shù)據(jù)庫時間，只能操作到日期，不能讀取和修改時間；

• java.sql.Time:表示數(shù)據(jù)庫時間；

• java.sql.Timestamp:時間戳；

• Calendar:工具類，提供時間的加減等復(fù)雜操作，支持時區(qū)；
  Calendar負(fù)責(zé)對Date中特定信息，比如這個時間是該年的第幾個星期
  此外，還可以通過set,add,roll接口來進(jìn)行日期時間的增減

• TimeZone:表示時區(qū)；

• SimpleDateFormat：日期格式化類，非常常用
  SimpleDateFormat主要作為一些格式化的輸入輸出

Date java.util包

構(gòu)造器：

java.util 包提供了 Date 類來封裝當(dāng)前的日期和時間 Date 類提供兩個構(gòu)造函數(shù)來實例化 Date 對象

第一個構(gòu)造函數(shù)使用當(dāng)前日期和時間來初始化對象
new Date();

第二個構(gòu)造函數(shù)接收一個參數(shù)，該參數(shù)是從1970年1月1日起的毫秒數(shù)。
new Date(long l);

第三個還有很多構(gòu)造器被 @Deprecated 被Java過時注解標(biāo)記為,以過期了... "并不是不能使用,而是不建議使用...已經(jīng)過期了."
@Deprecated
public Date(int year, int month, int date){ ... }           "該構(gòu)造器輸入的 年月日 創(chuàng)建日期對象, year month 并不準(zhǔn)確存在偏移量！" 
                                                            應(yīng)該是這個被淘汰了吧, JDK8出現(xiàn)LocalDate "和他功能類似！"
...

常用方法：

long        getTime( )              返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數(shù)。
String      toString( )             把此 Date 對象轉(zhuǎn)換為以下形式的 String
                                    dow mon dd hh:mm:ss zzz yyyy 其中：dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)
boolean     after(Date date)        若當(dāng)調(diào)用此方法的Date對象在指定日期之后返回true,否則返回false
boolean     before(Date date)       若當(dāng)調(diào)用此方法的Date對象在指定日期之前返回true,否則返回false
int         compareTo(Date date)    比較當(dāng)調(diào)用此方法的Date對象和指定日期。兩者相等時候返回0, 
                                    調(diào)用對象在指定日期之前則返回負(fù)數(shù)
                                    調(diào)用對象在指定日期之后則返回正數(shù)    
boolean     equals(Object date)     Date 重寫的Object類的方法！ 使其比較的不在是地址！                                 

Demo:

package com.wsm.date;
import java.util.Date;

/**
 * Java.util.Date 時間類的使用:
 */
public class DateDemo {
    public static void main(String[] args) {
        //Java.util 包提供了 Date類來封裝當(dāng)前的日期和時間
        //Date類提供兩個構(gòu)造函數(shù)來實例化 Date 對象

        //new Date(); 構(gòu)造器;
        Date d1 = new Date();           //默認(rèn)獲取當(dāng)前日期;
        System.out.println("new Date():\t"+d1);         //Date類默認(rèn)重寫的 toString(); 不直接打印地址！但,因為Java是老外開發(fā)的,日期格式并不符號中國~

        //new Date(Long l); 構(gòu)造器;
        long l = System.currentTimeMillis();    //獲取當(dāng)前日期時間戳..毫秒數(shù)~
        Date d2 = new Date(l);          //根據(jù): 給定的時間戳,獲取指定日期...
        System.out.println("new Date(Long):\t"+d2);

        //還有很多其它的構(gòu)造器,但是都過期了..
        //Java注解: @Deprecated 注釋的方法類,表示JDK以過期不在維護的類,但并不影響使用...!

        /**
         * Date常用方法：
         */
        System.out.println("getTime():\t"+d1.getTime());       //getTime():  返回自1970 年 1 月 1 日 00:00:00 GMT 以來此Date對象,表示的毫秒數(shù);

        System.out.println("toString():\t"+d1.toString());      //toString(): 把此 Date 對象轉(zhuǎn)換為以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 格式;
        // dow 是一周中的某一天 (Sun, Mon, Tue,  Wed, Thu, Fri, Sat)
        // zzz是時間標(biāo)準(zhǔn),

        /** 其它很多方法都過時了 */
    }
}

Java.sql.Date

實例化 和 sql.Date 和 util.Date 相互轉(zhuǎn)換；

package com.wsm.date;

import java.util.Date;

/**
 * java.sql.Date對應(yīng)著數(shù)據(jù)庫中的日期類型的變量
 *      java.sql.Date extends java.util.Date  繼承Util.Date
 */
public class SqlDateDemo {

    public static void main(String[] args) {
        //創(chuàng)建java.sql.Date對象:
        //對應(yīng)數(shù)據(jù)中的日期變量！`雖然如此但是好像還是很少使用,一般也直接使用 util.Date`
        java.sql.Date date = new java.sql.Date(35235325345L);  //它只包含日期而沒有時間部分,輸出時候只顯示年月日！
        System.out.println(date);                              //1971-02-13

        /** 如何將java.util.Date對象轉(zhuǎn)換為java.sql.Date對象 */
        //情況一:
        //sql.Date 本質(zhì)上繼承了 util.Date
        Date date1 = new java.sql.Date(2343243242323L);         //子類賦值父類
        java.sql.Date dateS = (java.sql.Date) date1;            //然后在強轉(zhuǎn)回, 因為date1 本來就是 sql.Date類型 可以強轉(zhuǎn)回 sql.Date;
        System.out.println(dateS);

        
        /** 運行報錯！ 父類前置轉(zhuǎn)換成子類... */
        //情況二:
//        java.sql.Date date2 = (java.sql.Date)new Date();        //父類直接強轉(zhuǎn)子類,編譯不報錯運行報錯
        //因為:
        //      子類直接向上轉(zhuǎn)換成父類, 并可以強轉(zhuǎn)回子類:
        //          子類本身繼承父類擁有父類的屬性方法,本身屬于 父類/子類可以來回轉(zhuǎn)換！
        //      但:
        //          子類繼承父類,可以聲明自己特有的方法屬性... 父類直接轉(zhuǎn)換子類,可能回不存在特有的屬性方法(); 故程序報錯！


        /** java.util.Date對象轉(zhuǎn)換為java.sql.Date對象 */
        //情況三:
        //      util.Date 存在一個方法 getTime(); 返回,當(dāng)前對象時間戳。
        //而:   sql.Date  剛好構(gòu)造函數(shù), 可以通過..時間戳聲明！
        Date date3 = new Date();
        java.sql.Date date4 = new java.sql.Date(date3.getTime());
        System.out.println("Java.util.Date:"+date3);
        System.out.println("Java.sql.Date:"+date4);
    }
}

總結(jié)：

sql.Date 本身繼承于 util.Date： 擁有 util.Date 的屬性方法..

• sql.Date 是為了，和數(shù)據(jù)庫的日期類型進(jìn)行匹配賦值使用, 但實際開發(fā)中更多還是 util.Date
• sql.Date 格式只能是：年月日
• util.Date 格式可以是：年月日時分秒...

Java.text.SimpleDateFormat

Date類的API不易于國際化，大部分被廢棄了

• SimpleDateFormat 是對日期類Date的格式化 和 解析;
  Date類型的toString 輸出的是英文格式的時間，而不同國家有自己的日期格式...
• SimpleDateFormat 就可以以特定的規(guī)則進(jìn)行日期的 格式化Format

SimpleDateFormatDemo

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

/**
 * SimpleDateFormat類:
 *      Date類的格式化 —— 解析
 *      格式化：日期 --->字符串
 *      解析：格式化的逆過程，字符串 ---> 日期
 *
 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //實例化SimpleDateFormat:使用默認(rèn)的構(gòu)造器
        SimpleDateFormat sdf = new SimpleDateFormat();  /** 默認(rèn)的解析規(guī)則就是：(兩位)年 月 日 ... */

        //格式化：日期 --->字符串
        Date date = new Date();
        System.out.println(date);

        //格式化~
        String format = sdf.format(date);
        System.out.println(format);

        //解析：格式化的逆過程，字符串 ---> 日期
        Date date1 = sdf.parse(format);             /** 需要處理異常: 這里就throws 拋出了~ */
        System.out.println(date1);

        /** 使用最多... */
        //*************按照指定的方式格式化和解析：調(diào)用帶參的構(gòu)造器*****************
//        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format1 = sdf1.format(date);
        System.out.println(format1);
        //解析:要求字符串必須是符合SimpleDateFormat識別的格式(通過構(gòu)造器參數(shù)體現(xiàn)),
        //否則，拋異常~
        Date date2 = sdf1.parse("2020-02-18 11:48:27");
        System.out.println(date2);
    }
}

日期和時間的格式化編碼

java.util.Calendar 日歷類

Calendar是一個抽象類，主用用于完成日期字段之間相互操作的功能

• Calendar實例的方法
  1.使用Calendar.getInstance()方法
  2.調(diào)用它的子類GregorianCalendar的構(gòu)造器
• 一個Calendar的實例是系統(tǒng)時間的抽象表示，通過get(int field)方法來取得想要的時間信息
  常量： YEAR年、MONTH月、DAY_OF_WEEK這一周第幾天、HOUR_OF_DAY這一月第幾天 MINUTE分鐘、SECOND秒
通過get(常量); 獲取指定的~
• 常用方法
  public final Date getTime()
  public void set(int field,int value)
  public void add(int field,int amount)
  public final void setTime(Date date)

注意：

• 獲取月份時：一月是0，二月是1，以此類推，12月是11
  獲取星期時：周日是1，周二是2 ， 。。。。周六是7

CalendarDemo.Java

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

/** 日歷類對象Calendar 使用； */
public class CalendarDemo {
    public static void main(String[] args) {
        //1.實例化
        //方式一：創(chuàng)建其子類（GregorianCalendar）的對象
//        Calendar gregoriancalendar = new GregorianCalendar();

        //方式二：調(diào)用其靜態(tài)方法getInstance()
        Calendar calendar = Calendar.getInstance();                 //獲取當(dāng)前日期的: Calendar日歷對象！
//        System.out.println(calendar.getClass());

        //2.常用方法
        //get():
        //  根據(jù)常量參數(shù),獲取對應(yīng)的日期值~
        int days = calendar.get(Calendar.DAY_OF_MONTH);             //獲取當(dāng)月的第幾天~
        System.out.println("當(dāng)月的第"+days+"天");                                   //打??！
        System.out.println("當(dāng)年的第"+calendar.get(Calendar.DAY_OF_YEAR)+"天");     //獲取當(dāng)年的第幾天~

        //set()
        //calendar可變性
        //  給當(dāng)前日歷對象 進(jìn)行年月賦值 返回值void: 直接返回給當(dāng)前對象賦值~
        calendar.set(Calendar.DAY_OF_MONTH,22);                     //給當(dāng)前日歷對象設(shè)置為: 當(dāng)月第22天
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("修改日歷為當(dāng)月,第"+days+"天");                                   //打印: 22

        //add(): 給當(dāng)前日歷對象進(jìn)行 + - 操作
        calendar.add(Calendar.DAY_OF_MONTH,-3);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);                                   //打印: 22-3

        //getTime():日歷類---> Date
        //  根據(jù)當(dāng)前日歷對象的時間,返回一個Date類型數(shù)據(jù)~
        Date date = calendar.getTime();
        System.out.println(date);

        //setTime():Date ---> 日歷類
        //  將一個Date類型數(shù)據(jù),轉(zhuǎn)換為: 日歷對象！
        Date date1 = new Date();
        calendar.setTime(date1);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
    }
}

JDK8 新增的日期時間 API

前言：

Java8 之前的日期，Date JDK1.0 時引入 基本可以滿足基本的需求。
但，我們希望時間可以與晝夜 季節(jié) 四季有關(guān)，JDK1.1 引入了 Calendar類

• 而Calendar類并不比Date類好多少，它們面臨的問題

• 可變性：

  calendar.set(Calendar.DAY_OF_MONTH,22);                     //給當(dāng)前日歷對象設(shè)置為: 當(dāng)月第22天
  Calendar類的:
      Set(); 方法,賦值會直接改變當(dāng)前的類對象,這在Java 被成為 "可變性"
  

• 偏移性：

  JDK8 之前時間的類Date 類其實是存在一個構(gòu)造器： "可以直接年月日返回 Date對象..."
  但
  Date中的年份是從1900開始的，而月份都從0開始, "直接賦值年月日,實際上返回的日期并不準(zhǔn)確,Date是存在偏移量的！"
  
  //JDK8之前日期問題...Date存在便宜量~
  @Test
  public void offsetDate(){
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  
      //Date(year, month, date);
      Date d1 = new Date(2000, 9, 9);     //創(chuàng)建一個2020 9月9日的日期對象;
      System.out.println("Date類存在偏移量:");
      System.out.println("未設(shè)置偏移量輸出:"+sdf.format(d1));
  
      //設(shè)置便宜量:
      //Date 正因為存在偏移量,而被淘汰！ 而年便宜了 1900年 月默認(rèn)從0開始~所以 2020 09 09  應(yīng)該這個樣寫！
      Date d2 = new Date(2000-1900, 9-1, 9);
      System.out.println("設(shè)置偏移量輸出: "+sdf.format(d2));   //正常輸出 20200909
  }
  
  
  //控制臺輸出：
  Date類存在偏移量:
  未設(shè)置偏移量輸出:3900-10-09
  設(shè)置偏移量輸出: 2000-09-09
  

• 格式化：
  格式化只對Date有用，Calendar則不行。 此外，它們也不是線程安全的；不能處理閏秒等。

Java8 新增API

對日期和時間的操作一直是Java程序員最痛苦的地方之一
因此：

• Java8 之前出現(xiàn)了，Joda-Time.Jar包 周大-泰~ 來更方便的操作，日期API

• 而后，JDK8之后，為了方便用戶操作，直接集成了該Jar包的功能！
  不在需要用戶，每次都要引入 Joda-Time.Jar 依賴~
  當(dāng)然如果，你現(xiàn)在公司是Java7 你還想用這些時間ApI 還需要引入 Joda-Time.Jar包

• 本地日期（LocalDate）
  本地時間 （LocalTime）
  本地日期時間（LocalDateTime）
  時區(qū)（ZonedDateTime）
  ....

• 為了方便操作，古老的Data類 Java8之后，也新增了 toInstant() 方法;
  用于將，Date 轉(zhuǎn)換成新的表示形式，這些新增的本地化時間日期 API 大大簡化了日期時間和本地化的管理。

LocalDate / Time / DateTime

LocalDate、LocalTime、LocalDateTime

• LocalDate、LocalTime、LocalDateTime 類是其中較重要的幾個類 它們的實例 是不可變的對象
• 分別表示使用 ISO-8601日歷系統(tǒng)的日期、時間、日期和時間
  它們提供了簡單的本地日期或時間，并不包含當(dāng)前的時間信息，也不包含與時區(qū)相關(guān)的信息
• LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存儲 生日、紀(jì)念日等日期
• LocalTime表示一個時間，而不是日期
• LocalDateTime是用來表示日期和時間的，這是一個最常用的類之一

ISO

• ISO 國際標(biāo)準(zhǔn)化組織(International Organization for Standardization
  
  在這里插入圖片描述

常用方法

Demo

LocalDateTimeDemo.Java

import org.junit.Test;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Date;

/**
 * JDK8之后的日期API
 *      LocalDate       年月日~
 *      LocalTime       時分秒~
 *      LocalDateTime   年月日時分秒~
 *      三者,方法類似,都是JDK8 之后新增的日期類,分別用于表示不同的時間 日期 時間日期 描述的Java對象！
 */
public class LocalDateTimeDemo {

    /** LocalDate LocalTime LocalDateTime 使用/常用方法();
     *      LocalDateTime相較于LocalDate、LocalTime，使用頻率要高
     *      類似于Calendar
     * */
    public static void main(String[] args) {
        //now():獲取當(dāng)前的日期、時間、日期+時間
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println("localDate:\t"+localDate);
        System.out.println("localTime:\t"+localTime);
        System.out.println("localDateTime:\t"+localDateTime);
        /** 三個類重寫了toString(); 直接輸入的就是中國的日期格式~ */


        //of():設(shè)置指定的年、月、日、時、分、秒。沒有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
        System.out.println(localDateTime1);


        //getXxx()：獲取相關(guān)的屬性
        System.out.println(localDateTime.getDayOfMonth());      //獲取當(dāng)前日是這個月的第幾天
        System.out.println(localDateTime.getDayOfWeek());       //獲取當(dāng)前時間是一周中的哪一天
        System.out.println(localDateTime.getMonth());           //獲取當(dāng)前月份
        System.out.println(localDateTime.getMonthValue());      //獲取月份信息
        System.out.println(localDateTime.getMinute());          //獲取分鐘
        /** 三個類均可調(diào)用類似的方法~ 注意要存在符合的條件~ */

        /** 體現(xiàn)不可變性 */
        //withXxx():設(shè)置相關(guān)的屬性
        //  LocalDate　對象通過withxx(); 給日期對象設(shè)置日期屬性,但是,并不會改變當(dāng)前對象,而是會返回一個對象,是更高后的日期~ 本類并不會收受到影響~
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println("更新前對象:"+localDate);
        System.out.println("更新后對象:"+localDate1);

        //plusxxx();    向當(dāng)前對象添加幾天、幾周、幾個月、幾年、幾小時
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);
        System.out.println(localDateTime3);

        //minusxxx();   向當(dāng)前對象添加幾天、幾周、幾個月、幾年、幾小時
        LocalDateTime localDateTime4 = localDateTime.minusDays(6);
        System.out.println(localDateTime);
        System.out.println(localDateTime4);
    }
    
    //JDK8之前日期問題...Date存在便宜量~
    @Test
    public void offsetDate(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        //Date(year, month, date);
        Date d1 = new Date(2000, 9, 9);     //創(chuàng)建一個2020 9月9日的日期對象;
        System.out.println("Date類存在偏移量:");
        System.out.println("未設(shè)置偏移量輸出:"+sdf.format(d1));

        //設(shè)置便宜量:
        //Date 正因為存在偏移量,而被淘汰！ 而年便宜了 1900年 月默認(rèn)從0開始~所以 2020 09 09  應(yīng)該這個樣寫！
        Date d2 = new Date(2000-1900, 9-1, 9);
        System.out.println("設(shè)置偏移量輸出: "+sdf.format(d2));   //正常輸出 20200909
    }
}

Instant

Instant

• 時間線上的一個瞬時點。 這可能被用來記錄應(yīng)用程序中的事件時間戳

常用方法

Demo

InsantDemo.Java

import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

/***
 * Instant 類的Demo學(xué)習(xí)
 *
 */
public class InsantDemo {
    public static void main(String[] args) {
        //now():獲取本初子午線對應(yīng)的標(biāo)準(zhǔn)時間
        Instant instant = Instant.now();
        System.out.println(instant);//2019-02-18T07:29:41.719Z      //

        //北京世界東八區(qū)！ 1949年起的逾半世紀(jì)，在中國大陸、臺灣、香港、澳門所使用的標(biāo)準(zhǔn)時間皆為東八區(qū)（UTC+8）時間
        //中國,占五個時區(qū).分別是東5區(qū) 東6區(qū) 東7區(qū) 東8區(qū) 東9區(qū) 據(jù)北京較遠(yuǎn)的地區(qū)也有不使用北京時間的 比如烏魯木齊時間就是東九區(qū)時間,比北京時間早一個小時 世界分24個時區(qū)

        //添加時間的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2019-02-18T15:32:50.611+08:00

        //toEpochMilli(): 獲取自1970年1月1日0時0分0秒（UTC）開始的毫秒數(shù)  ---> Date類的getTime()
        long milli = instant.toEpochMilli();
        System.out.println(milli);

        //ofEpochMilli():通過給定的毫秒數(shù)，獲取Instant實例  -->Date(long millis)
        Instant instant1 = Instant.ofEpochMilli(1550475314878L);
        System.out.println(instant1);
    }
}

DateTimeFormatter

DateTimeFormatter

該類提供了三種格式化方法：

• 預(yù)定義的標(biāo)準(zhǔn)格式
  就是默認(rèn)的日期格式化~ 不需要任何指定~
• 本地化相關(guān)的格式
  提供了幾種定義好的枚舉，格式化類型~ 年月日時分秒 yyyy-MM-DD HH:mm:ss
• 自定義的格式
  通過：ofPattern(yyyymm); 來指定日期的格式~

常用方法：

• 格式化： 將日期(對象) 轉(zhuǎn)換為字符串~
• 解析： 將字符串日期轉(zhuǎn)換為~ 日期對象 轉(zhuǎn)換的字符 和 日期對象的格式要一致, 不然轉(zhuǎn)換失??！

Demo

DateTimeFormatterDemo.Java

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

/** DateTimeFormatter */
public class DateTimeFormatterDemo {
    public static void main(String[] args) {
//      方式一：預(yù)定義的標(biāo)準(zhǔn)格式。如：ISO_LOCAL_DATE_TIME;  ISO_LOCAL_DATE;   ISO_LOCAL_TIME       分布對應(yīng)三個對象！
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化:日期-->字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);
        System.out.println(str1);//2019-02-18T15:42:18.797
        //解析：字符串 -->日期
        TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
        System.out.println(parse);

        
//      方式二：
//      本地化相關(guān)的格式。如：ofLocalizedDateTime()
//      FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :適用于LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        //格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2019年2月18日 下午03時47分16秒

//      本地化相關(guān)的格式。如：ofLocalizedDate()
//      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 適用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
        //格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);//2019-2-18


//       重點： 方式三：自定義的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化
        String str4 = formatter3.format(LocalDateTime.now());
        System.out.println(str4);//2019-02-18 03:52:09

        //解析
        TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
        System.out.println(accessor);
    }
}

總結(jié)：

Java8 新增了很多的日期API 其實常用的也就以上...

• Java8之前的其實還有很多人使用，JDK是向下兼容的，所以不必?fù)?dān)心
• 但，8聽說效率還挺高，而且確實挺方便的...

JDK8其它API

在這里插入圖片描述

System Java系統(tǒng)類：

java.lang 包下的一個 系統(tǒng)類，可以通過該類獲取的當(dāng)前計算機的：屬性~

• 該類的構(gòu)造器是private的 所以無法創(chuàng)建該類的對象，也就是無法實例化該類.
  其內(nèi)部的成員變量和成員方法都是static的，所以也可以很方便的進(jìn)行調(diào)用

成員變量

• System類內(nèi)部包含in、out和err三個成員變量
  分別代表標(biāo)準(zhǔn)輸入流 (鍵盤輸入)
  標(biāo)準(zhǔn)輸出流(顯示器)
  標(biāo)準(zhǔn)錯誤輸出流(顯示器)

成員方法

Sacnner 掃描器：

java.util.Scanner 是 Java5 的新特征，我們可以通過 Scanner 類來獲取用戶的控制臺輸入
需要搭配 System.in 的輸入流~ Scanner s = new Scanner(System.in);

常用方法：

如果要輸入 int 或 float 類型的數(shù)據(jù)，在 Scanner 類中也有支持
next.Byte() nextDouble() nextFloat,nextInt() nextLin() nextLong() nextShot()
但是在輸入之前最好先使用 hasNextXxx() 方法進(jìn)行驗證，再使用 nextXxx() 來讀取，不然輸入int 的輸入了一個 String會報錯~

 /** 成員屬性: in out err */
     //in:   配合Scanner 掃描器,可以實現(xiàn)控制臺的輸入流...
     //out:  這個,最常用: System.out.print(); 返回一個輸出流,輸出信息
     //err:  和out 類似,但是它輸出的信息一般表示錯誤,比較顯眼的 紅色信息！
 //創(chuàng)建一個掃描儀
 Scanner scanner = new Scanner(System.in);
 System.out.println("請輸入一段話s1:");
 String s1 = scanner.next();
 System.out.println("請輸入一段話s2:");
 String s2 = scanner.next();
 System.err.println("s1:"+s1);
 System.err.println("s2:"+s2);
 //注意: 不要同時兩個
 // scanner.nextxxx() 寫在一起,這些方法執(zhí)行時都會造成堵塞，等待用戶在命令行輸入數(shù)據(jù)回車確認(rèn).
 // 寫在一起,輸入了一個回車,則所有的 nextxxx() 都結(jié)束了！
 scanner.close();                /** 要注意關(guān)閉流o 不然占用程序資源... */

SystemDemo

SysDemo.Java

import java.util.Scanner;

/**
 * System 系統(tǒng)類的學(xué)習(xí)...
 */
public class SysDemo {
    //main 主方法...
    public static void main(String[] args) {

        /** 成員屬性: in out err */
            //in:   配合Scanner 掃描器,可以實現(xiàn)控制臺的輸入流...
            //out:  這個,最常用: System.out.print(); 返回一個輸出流,輸出信息
            //err:  和out 類似,但是它輸出的信息一般表示錯誤,比較顯眼的 紅色信息！
        //創(chuàng)建一個掃描儀
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入一段話s1:");
        String s1 = scanner.next();
        System.out.println("請輸入一段話s2:");
        String s2 = scanner.next();
        System.err.println("s1:"+s1);
        System.err.println("s2:"+s2);
        //注意: 不要同時兩個
        // scanner.nextxxx() 寫在一起,這些方法執(zhí)行時都會造成堵塞，等待用戶在命令行輸入數(shù)據(jù)回車確認(rèn).
        // 寫在一起,輸入了一個回車,則所有的 nextxxx() 都結(jié)束了！
        scanner.close();                /** 要注意關(guān)閉流o 不然占用程序資源... */

        /** currentTimeMillis */
        long timeStamp = System.currentTimeMillis();    //返回當(dāng)前時間,時間戳;
        //時間戳: 值當(dāng)前日期距離,格林威治時間(GMT)1970-01-01  的毫秒數(shù)~
        //使用:
        //  通常可以,用于生產(chǎn)一個時間戳, 時間唯一的一個ID, 用作在數(shù)據(jù)庫/文件名...表示數(shù)據(jù)唯一~
        System.out.println(timeStamp);


        /** getProperty(): 獲取系統(tǒng)的參數(shù)信息！*/
        String javaVersion = System.getProperty("java.version");
        System.out.println("java的環(huán)境版本:" + javaVersion);

        String javaHome = System.getProperty("java.home");
        System.out.println("java的安裝路徑:" + javaHome);

        String osName = System.getProperty("os.name");
        System.out.println("操作系統(tǒng)的名稱:" + osName);

        String osVersion = System.getProperty("os.version");
        System.out.println("操作系統(tǒng)的版本:" + osVersion);

        String userName = System.getProperty("user.name");
        System.out.println("計算機用戶賬戶名:" + userName);

        String userHome = System.getProperty("user.home");
        System.out.println("用戶的主目錄:" + userHome);

        String userDir = System.getProperty("user.dir");
        System.out.println("用戶當(dāng)前工作目錄:" + userDir);
    }
}

在這里插入圖片描述

Math Java數(shù)學(xué)類：

Java 的 Math 包含了用于執(zhí)行基本數(shù)學(xué)運算的屬性和方法，如初等指數(shù)、對數(shù)、平方根和三角函數(shù)
Math 的方法都被定義為 static 形式，通過 Math 類可以在主函數(shù)中直接調(diào)用 不用new 可以直接調(diào)用！

常用方法：

MathDemo

MathDemo.Java

public static void main(String[] args) {
/** 算術(shù)計算 */
    System.out.println("--------算術(shù)計算-----------");
    System.out.println(Math.sqrt(16));          // 4.0      4^2 4的二次方=16
    System.out.println(Math.cbrt(8));           // 2.0      2^3 2的三次方= 8
    System.out.println(Math.pow(3, 2));         // 9.0      3^2 3的二次方=16     幾次方就是, x乘x次! 3x3=9
    System.out.println(Math.max(2.3, 4.5));     // 4.5      判斷最大值！
    System.out.println(Math.min(2.3, 4.5));     // 2.3      判斷最小值！

    /**
     * abs求絕對值: 就是把一個數(shù)變成 + 正數(shù)！
     */
    System.out.println(Math.abs(-10.4));        // 10.4
    System.out.println(Math.abs(10.1));         // 10.1

/** 進(jìn)位 */
    System.out.println("--------進(jìn)位-----------");
    /**
     * ceil天花板的意思，就是逢余進(jìn)一
     *      正數(shù)+1
     *      小數(shù)+1, 小數(shù)+1~
     */
    System.out.println("--------ceil-----------");
    System.out.println(Math.ceil(-10.1));       // -10.0
    System.out.println(Math.ceil(10.7));        // 11.0
    System.out.println(Math.ceil(-0.7));        // -0.0
    System.out.println(Math.ceil(0.0));         // 0.0
    System.out.println(Math.ceil(-0.0));        // -0.0
    System.out.println(Math.ceil(-1.7));        // -1.0

    /**
     * floor地板的意思，就是逢余舍一
     */
    System.out.println("--------floor-----------");
    System.out.println(Math.floor(-10.1));      // -11.0
    System.out.println(Math.floor(10.7));       // 10.0
    System.out.println(Math.floor(-0.7));       // -1.0
    System.out.println(Math.floor(0.0));        // 0.0
    System.out.println(Math.floor(-0.0));       // -0.0

    /**
     * rint 四舍五入，返回double值 注意.5的時候會取偶數(shù) 異常的尷尬=。=
     */
    System.out.println("--------rint-----------");
    System.out.println(Math.rint(10.1)); // 10.0
    System.out.println(Math.rint(10.7)); // 11.0
    System.out.println(Math.rint(11.5)); // 12.0
    System.out.println(Math.rint(10.5)); // 10.0
    System.out.println(Math.rint(10.51)); // 11.0
    System.out.println(Math.rint(-10.5)); // -10.0

    /**
     * round 四舍五入，float時返回int值，double時返回long值
     */
    System.out.println("--------round-----------");
    System.out.println(Math.round(10)); // 10
    System.out.println(Math.round(10.1)); // 10
    System.out.println(Math.round(10.7)); // 11
    System.out.println(Math.round(10.5)); // 11
    System.out.println(Math.round(10.51)); // 11
    System.out.println(Math.round(-10.5)); // -10
}

獲取100以內(nèi)的隨機數(shù)！

 @Test
  /** 獲取100以內(nèi)的隨機數(shù)！ */
  public void randomHundred(){
      // Math.random() 獲取0-1 的隨機數(shù)! 包含0!
      System.out.println("隨機0-1");
      System.out.println(Math.random());

      System.out.println("隨機0-100");
      System.out.println((int)(Math.random()*100)+1);
      /**
       * (int)(Math.random()*100)+1
       *  因為: Math.random() 獲取0-1 的隨機數(shù)! 包含0!
       *      *100 獲取隨機數(shù)進(jìn)兩位小數(shù),強制轉(zhuǎn)換(int) 會截取小數(shù)點..
       *      因為包含0 所以+1 就不會出現(xiàn)呢0 的情況了！?。?       */
  }

BigInteger 與 BigDecimal 類：

BigInteger

Java.math包
Interger類作為int的包裝類，能存儲的最大整型值為2^{31-1}
Long類也是有限的， 最大為2^{63-1}

• 如果要表示再大的整數(shù)，不管是基本數(shù)據(jù)類型還是他們的包裝類都無能為力，更不用說進(jìn)行運算了
• BigInteger 提供所有 Java 的基本整數(shù)操作符的對應(yīng)物
  并提供 Java.lang.Math 的所有相關(guān)方法
• BigInteger 還提供以下運算：
  模算術(shù)、GCD 計算、質(zhì)數(shù)測試、素數(shù)生成、 位操作以及一些其他操作

構(gòu)造器

• BigInteger(String val)：根據(jù)字符串構(gòu)建BigInteger對象

常用方法：

BigInteger abs()                    返回大整數(shù)的絕對值
BigInteger add(BigInteger val)      返回兩個大整數(shù)的和
BigInteger and(BigInteger val)      返回兩個大整數(shù)的按位與的結(jié)果
BigInteger andNot(BigInteger val)   返回兩個大整數(shù)與非的結(jié)果
BigInteger divide(BigInteger val)   返回兩個大整數(shù)的商
double doubleValue()                返回大整數(shù)的double類型的值
float floatValue()                  返回大整數(shù)的float類型的值
BigInteger gcd(BigInteger val)      返回大整數(shù)的最大公約數(shù)
int intValue()                      返回大整數(shù)的整型值
long longValue()                    返回大整數(shù)的long型值
BigInteger max(BigInteger val)      返回兩個大整數(shù)的最大者
BigInteger min(BigInteger val)      返回兩個大整數(shù)的最小者
BigInteger mod(BigInteger val)      用當(dāng)前大整數(shù)對val求模
BigInteger multiply(BigInteger val) 返回兩個大整數(shù)的積
BigInteger negate()                 返回當(dāng)前大整數(shù)的相反數(shù)
BigInteger not()                    返回當(dāng)前大整數(shù)的非
BigInteger or(BigInteger val)       返回兩個大整數(shù)的按位或
BigInteger pow(int exponent)        返回當(dāng)前大整數(shù)的exponent次方
BigInteger remainder(BigInteger val)返回當(dāng)前大整數(shù)除以val的余數(shù)
BigInteger leftShift(int n)         將當(dāng)前大整數(shù)左移n位后返回
BigInteger rightShift(int n)        將當(dāng)前大整數(shù)右移n位后返回
BigInteger subtract(BigInteger val) 返回兩個大整數(shù)相減的結(jié)果
byte[] toByteArray(BigInteger val)  將大整數(shù)轉(zhuǎn)換成二進(jìn)制反碼保存在byte數(shù)組中
String toString()                   將當(dāng)前大整數(shù)轉(zhuǎn)換成十進(jìn)制的字符串形式
BigInteger xor(BigInteger val)      返回兩個大整數(shù)的異或

BigDecimal

Decimal：[中：小數(shù)]
一般的Float類和Double類可以用來做科學(xué)計算或工程計算
但在商業(yè)計算中， 要求數(shù)字精度比較高，故用到 Java.math.BigDecimal類
BigDecimal類支持不可變的、任意精度的有符號十進(jìn)制定點數(shù)
　
構(gòu)造器

• public BigDecimal(double val)
• public BigDecimal(String val)

常用方法

add(BigDecimal)         BigDecimal對象中的值相加，然后返回這個對象。 
subtract(BigDecimal)    BigDecimal對象中的值相減，然后返回這個對象。 
multiply(BigDecimal)    BigDecimal對象中的值相乘，然后返回這個對象。 
divide(BigDecimal)      BigDecimal對象中的值相除，然后返回這個對象。 
toString()              將BigDecimal對象的數(shù)值轉(zhuǎn)換成字符串。 
doubleValue()           將BigDecimal對象中的值以雙精度數(shù)返回。 
floatValue()            將BigDecimal對象中的值以單精度數(shù)返回。 
longValue()             將BigDecimal對象中的值以長整數(shù)返回。 
intValue()              將BigDecimal對象中的值以整數(shù)返回

Java的 flot double 計算有問題:

查看下面的代碼：

 @Test
  public void bigDecimal(){
      System.out.println(0.1+0.2);
      System.out.println(0.3-0.1);
      System.out.println(0.2*0.1);
      System.out.println(0.3/0.1);
  }

在這里插入圖片描述

• 根本原因是:十進(jìn)制值通常沒有完全相同的二進(jìn)制表示形式
• 十進(jìn)制數(shù)的二進(jìn)制表示形式可能不精確。只能無限接近于那個值

但：

• 在項目中，我們不可能讓這種情況出現(xiàn)，特別是金融項目
• 如果你的支付寶賬戶余額顯示193.99999999999998，那是一種怎么樣的體驗？ ??