14-正則表達式/Pattern和Matcher/Math類/Random類/System類/SimpleDateFormat類/Calendar類

14.01_常見對象(正則表達式的概述和簡單使用)

• A:正則表達式
  
  • 是指一個用來描述或者匹配一系列符合某個語法規則的字符串的單個字符串。其實就是一種規則。有自己特殊的應用。
  • 作用:比如註冊郵箱,郵箱有用戶名和密碼,一般會對其限制長度,這個限制長度的事情就是正則表達式做的

• B:案例演示

  • 需求：校驗qq號碼.

    • 1:要求必須是5-15位數字
    • 2:0不能開頭
    • 3:必須都是數字

  • a:非正則表達式實現

  • b:正則表達式實現

package com.heima.regex;

public class Demo1_Regex {

    public static void main(String[] args) {
        System.out.println(checkQQ("012345"));
        System.out.println(checkQQ("a1b345"));
        System.out.println(checkQQ("123456"));
        System.out.println(checkQQ("1234567890987654321"));

        String regex = "[1-9]\\d{4,14}";
        System.out.println("2553868".matches(regex));
        System.out.println("012345".matches(regex));
        System.out.println("2553868abc".matches(regex));
    }

    /*
     * 需求：校驗qq號碼.
     * 1:要求必須是5-15位數字
     * 2:0不能開頭
     * 3:必須都是數字
     * 校驗qq
     * 1,明確返回值類型boolean
     * 2,明確參數列表String qq
     */
    public static boolean checkQQ(String qq) {
        boolean flag = true;                    //如果校驗qq不符合要求就把flag置爲false,如果符合要求直接返回

        if(qq.length() >= 5 && qq.length() <= 15) {
            if(!qq.startsWith("0")) {
                char[] arr = qq.toCharArray();  //將字符串轉換成字符數組
                for (int i = 0; i < arr.length; i++) {
                    char ch = arr[i];           //記錄每一個字符
                    if(!(ch >= '0' && ch <= '9')) {
                        flag = false;           //不是數字
                        break;
                    }
                }
            }else {
                flag = false;                   //以0開頭,不符合qq標準
            }
        }else {
            flag = false;                       //長度不符合
        }
        return flag;
    }
}

14.02_常見對象(字符類演示)

• A:字符類
  
  • [abc] a、b 或 c（簡單類）
  • [^abc] 任何字符，除了 a、b 或 c（否定）
  • [a-zA-Z] a到 z 或 A到 Z，兩頭的字母包括在內（範圍）
  • [0-9] 0到9的字符都包括

package com.heima.regex;

public class Demo2_Regex {

    /**
     * [abc] a、b 或 c（簡單類） 
        [^abc] 任何字符，除了 a、b 或 c（否定） 
        [a-zA-Z] a 到 z 或 A 到 Z，兩頭的字母包括在內（範圍） 
        [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（並集） 
        [a-z&&[def]] d、e 或 f（交集） 
        [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（減去） 
        [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（減去） 

     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        //demo4();
        //demo5();
        //demo6();
        String regex = "[a-z&&[^m-p]]";
        System.out.println("m".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("z".matches(regex));
        System.out.println("n".matches(regex));
    }

    private static void demo6() {
        String regex = "[a-z&&[^bc]]";
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("1".matches(regex));
    }

    private static void demo5() {
        String regex = "[a-z&&[def]]";                      //取交集
        System.out.println("a".matches(regex));
        System.out.println("d".matches(regex));
    }

    private static void demo4() {
        String regex = "[a-d[m-p]]";
        System.out.println("a".matches(regex));
        System.out.println("m".matches(regex));
        System.out.println("n".matches(regex));
    }

    private static void demo3() {
        String regex = "[a-zA-Z]";
        System.out.println("a".matches(regex));
        System.out.println("A".matches(regex));
        System.out.println("z".matches(regex));
        System.out.println("Z".matches(regex));
        System.out.println("1".matches(regex));
        System.out.println("%".matches(regex));
    }

    private static void demo2() {
        String regex = "[^abc]";
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println("1".matches(regex));
        System.out.println("%".matches(regex));
        System.out.println("10".matches(regex));        //10代表1字符和0字符,不是單個字符
    }

    private static void demo1() {
        String regex = "[abc]";                 //[]代表單個字符
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println("1".matches(regex));
        System.out.println("%".matches(regex));
    }

}

14.03_常見對象(預定義字符類演示)

• A:預定義字符類
  
  • . 任何字符。
  • \d 數字：[0-9]
  • \w 單詞字符：[a-zA-Z_0-9]

package com.heima.regex;

public class Demo3_Regex {

    /**
     *  . 任何字符
        \d 數字：[0-9] 
        \D 非數字： [^0-9] 
        \s 空白字符：[ \t\n\x0B\f\r] 
        \S 非空白字符：[^\s] 
        \w 單詞字符：[a-zA-Z_0-9] 
        \W 非單詞字符：[^\w] 

     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        //demo4();
        //demo5();
        //demo6();
        String regex = "\\W";
        System.out.println("a".matches(regex));
        System.out.println("z".matches(regex));
        System.out.println("_".matches(regex));
        System.out.println("%".matches(regex));
    }

    private static void demo6() {
        String regex = "\\w";
        System.out.println("a".matches(regex));
        System.out.println("z".matches(regex));
        System.out.println("_".matches(regex));
        System.out.println("%".matches(regex));
    }

    private static void demo5() {
        String regex = "\\S";
        System.out.println(" ".matches(regex));
        System.out.println("    ".matches(regex));
        System.out.println("a".matches(regex));
    }

    private static void demo4() {
        String regex = "\\s";
        System.out.println(" ".matches(regex));
        System.out.println("    ".matches(regex));              //一個tab鍵
        System.out.println("    ".matches(regex));              //四個空格
    }

    private static void demo3() {
        String regex = "\\D";
        System.out.println("0".matches(regex));
        System.out.println("9".matches(regex));
        System.out.println("a".matches(regex));
    }

    private static void demo2() {
        String regex = "\\d";                   //\代表轉義字符,如果想表示\d的話,需要\\d
        System.out.println("0".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("9".matches(regex));
    }

    private static void demo1() {
        String regex = "..";
        System.out.println("a".matches(regex));
        System.out.println("ab".matches(regex));
    }

}

14.04_常見對象(數量詞)

• A:Greedy 數量詞
  
  • X? X，一次或一次也沒有
  • X* X，零次或多次
  • X+ X，一次或多次
  • X{n} X，恰好 n 次
  • X{n,} X，至少 n 次
  • X{n,m} X，至少 n 次，但是不超過 m 次

package com.heima.regex;

public class Demo4_Regex {

    /**
     * Greedy 數量詞 
        X? X，一次或一次也沒有 
        X* X，零次或多次 
        X+ X，一次或多次 
        X{n} X，恰好 n 次 
        X{n,} X，至少 n 次 
        X{n,m} X，至少 n 次，但是不超過 m 次 
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();
        //demo4();
        //demo5();
        String regex = "[abc]{5,15}";
        System.out.println("abcba".matches(regex));
        System.out.println("abcbaabcabbabab".matches(regex));
        System.out.println("abcb".matches(regex));
        System.out.println("abcbaabaabcbaaba".matches(regex));
    }

    public static void demo5() {
        String regex = "[abc]{5,}";
        System.out.println("abcba".matches(regex));
        System.out.println("abcbaabcabbabab".matches(regex));
        System.out.println("abcb".matches(regex));
        System.out.println("abcbaaba".matches(regex));
    }

    public static void demo4() {
        String regex = "[abc]{5}";
        System.out.println("abcba".matches(regex));
        System.out.println("abcbaabcabbabab".matches(regex));
        System.out.println("abcb".matches(regex));
        System.out.println("abcbaaba".matches(regex));
    }

    public static void demo3() {
        String regex = "[abc]+";
        System.out.println("".matches(regex));
        System.out.println("a".matches(regex));
        System.out.println("aaaaabbbbccccc".matches(regex));
    }

    public static void demo2() {
        String regex = "[abc]*";
        System.out.println("".matches(regex));
        System.out.println("abc".matches(regex));
        System.out.println("a".matches(regex));
    }

    public static void demo1() {
        String regex = "[abc]?";
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println("".matches(regex));
    }

}

14.05_常見對象(正則表達式的分割功能)

• A:正則表達式的分割功能
  
  • String類的功能：public String[] split(String regex)
• B:案例演示
  
  • 正則表達式的分割功能

package com.heima.regex;

public class Demo5_Split {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "金三胖.郭美美.李dayone";
        String[] arr = s.split("\\.");              //通過正則表達式切割字符串

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("11111111111111111");
    }

}

14.06_常見對象(把給定字符串中的數字排序)

• A:案例演示
  
  • 需求：我有如下一個字符串:”91 27 46 38 50”，請寫代碼實現最終輸出結果是：”27 38 46 50 91”

package com.heima.test;

import java.util.Arrays;

public class Test1 {

    /**
     * @param args
     * * A:案例演示
     * 需求：我有如下一個字符串:”91 27 46 38 50”，請寫代碼實現最終輸出結果是：”27 38 46 50 91”
     * 100
     * 80
     * 分析:
     * 1,將字符串切割成字符串數組
     * 2,將字符串轉換成數字並將其存儲在一個等長度的int數組中
     * 3,排序
     * 4,將排序後的結果遍歷並拼接成一個字符串
     */
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        //1,將字符串切割成字符串數組
        String[] sArr = s.split(" ");
        //2,將字符串轉換成數字並將其存儲在一個等長度的int數組中
        int[] arr = new int[sArr.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(sArr[i]);     //將數字字符串轉換成數字
        }

        //3,排序
        Arrays.sort(arr);

        //4,將排序後的結果遍歷並拼接成一個字符串27 38 46 50 91
        /*String str = "";
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1) {
                str = str + arr[i];             //27 38 46 50 91
            }else {
                str = str + arr[i] + " ";       //27 38 46 50 
            }
        }

        System.out.println(str);*/

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1) {
                sb.append(arr[i]);
            }else {
                sb.append(arr[i] + " ");
            }
        }

        System.out.println(sb);
    }

}

14.07_常見對象(正則表達式的替換功能)

• A:正則表達式的替換功能
  
  • String類的功能：public String replaceAll(String regex,String replacement)
• B:案例演示
  
  • 正則表達式的替換功能

package com.heima.regex;

public class Demo6_ReplaceAll {

    /**
     * * A:正則表達式的替換功能
     * String類的功能：public String replaceAll(String regex,String replacement)
     */
    public static void main(String[] args) {
        String s = "wo111ai222heima";
        String regex = "\\d";           //\\d代表的是任意數字

        String s2 = s.replaceAll(regex, "");
        System.out.println(s2);
    }

}

14.08_常見對象(正則表達式的分組功能)

• A:正則表達式的分組功能
  
  • 捕獲組可以通過從左到右計算其開括號來編號。例如，在表達式 ((A)(B(C))) 中，存在四個這樣的組：

• 1     ((A)(B(C))) 
  2     (A 
  3     (B(C)) 
  4     (C) 
  
  組零始終代表整個表達式。
  

  B:案例演示
  a:切割
  需求：請按照疊詞切割： “sdqqfgkkkhjppppkl”;
  b:替換
  需求：我我….我…我.要…要要…要學….學學..學.編..編編.編.程.程.程..程
  將字符串還原成:“我要學編程”。

package com.heima.regex;

public class Demo7_Regex {

    /**
     * * A:正則表達式的分組功能
            * 捕獲組可以通過從左到右計算其開括號來編號。例如，在表達式 ((A)(B(C))) 中，存在四個這樣的組： 
        * 
                1     ((A)(B(C))) 
                2     (A 
                3     (B(C)) 
                4     (C) 

                組零始終代表整個表達式。
        B:案例演示
            a:切割
                需求：請按照疊詞切割： "sdqqfgkkkhjppppkl";
            b:替換
                需求：我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程
                將字符串還原成:“我要學編程”。
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();

        /*
         * 需求：我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程
                將字符串還原成:“我要學編程”。
         */
        String s = "我我....我...我.要...要要...要學....學學..學.編..編編.編.程.程.程..程";
        String s2 = s.replaceAll("\\.+", "");
        String s3 = s2.replaceAll("(.)\\1+", "$1");	//$1代表第一組中的內容
        System.out.println(s3);
    }

    public static void demo2() {
        //需求：請按照疊詞切割： "sdqqfgkkkhjppppkl";
        String s = "sdqqfgkkkhjppppkl";
        String regex = "(.)\\1+";                   //+代表第一組出現一次到多次
        String[] arr = s.split(regex);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static void demo1() {
        //疊詞 快快樂樂,高高興興
        /*String regex = "(.)\\1(.)\\2";                    //\\1代表第一組又出現一次 \\2代表第二組又出現一次
        System.out.println("快快樂樂".matches(regex));
        System.out.println("快樂樂樂".matches(regex));
        System.out.println("高高興興".matches(regex));
        System.out.println("死啦死啦".matches(regex));*/

        //疊詞 死啦死啦,高興高興
        String regex2 = "(..)\\1";
        System.out.println("死啦死啦".matches(regex2));
        System.out.println("高興高興".matches(regex2));
        System.out.println("快快樂樂".matches(regex2));
    }

}

14.09_常見對象(Pattern和Matcher的概述)

• A:Pattern和Matcher的概述

• B:模式和匹配器的典型調用順序

  • 通過JDK提供的API，查看Pattern類的說明

  • 典型的調用順序是

  • Pattern p = Pattern.compile(“a*b”);
  • Matcher m = p.matcher(“aaaaab”);
  • boolean b = m.matches();

14.10_常見對象(正則表達式的獲取功能)

• A:正則表達式的獲取功能
  
  • Pattern和Matcher的結合使用
• B:案例演示
  
  • 需求：把一個字符串中的手機號碼獲取出來

package com.heima.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo8_Pattern {

    /**
     * Pattern p = Pattern.compile("a*b");
         Matcher m = p.matcher("aaaaab");
         boolean b = m.matches();

        * A:正則表達式的獲取功能
            * Pattern和Matcher的結合使用
        * B:案例演示
            * 需求：把一個字符串中的手機號碼獲取出來
     */
    public static void main(String[] args) {
        //demo1();
        String s = "我的手機是18988888888,我曾用過18987654321,還用過18812345678";
        String regex = "1[3578]\\d{9}";


        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(s);

        /*boolean b1 = m.find();
        System.out.println(b1);
        System.out.println(m.group());

        boolean b2 = m.find();
        System.out.println(b2);
        System.out.println(m.group());*/

        while(m.find())
            System.out.println(m.group());
    }

    public static void demo1() {
        Pattern p = Pattern.compile("a*b");                 //獲取到正則表達式
        Matcher m = p.matcher("aaaaab");                    //獲取匹配器
        boolean b = m.matches();                            //看是否能匹配,匹配就返回true

        System.out.println(b);

        System.out.println("aaaaab".matches("a*b"));        //與上面的結果一樣
    }

}

14.11_常見對象(Math類概述和方法使用)

• A:Math類概述
  
  • Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數。
• B:成員方法
  
  • 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) min自學
  • public static double pow(double a,double b)
  • public static double random()
  • public static int round(float a) 參數爲double的自學
  • public static double sqrt(double a)

package com.heima.otherclass;

public class Demo1_Math {

    /**
     * @param args
     * * A:Math類概述
        * Math 類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數。 
    * B:成員方法
        * 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) min自學
        * public static double pow(double a,double b)
        * public static double random()
        * public static int round(float a) 參數爲double的自學
        * public static double sqrt(double a)
     */
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-10));              //取絕對值

        //ceil天花板
        /*
         * 13.0
         * 12.3
         * 12.0
         */
        System.out.println(Math.ceil(12.3));            //向上取整,但是結果是一個double
        System.out.println(Math.ceil(12.99));

        System.out.println("-----------");
        //floor地板
        /*
         * 13.0
         * 12.3
         * 12.0
         */
        System.out.println(Math.floor(12.3));           //向下取整,但是結果是一個double
        System.out.println(Math.floor(12.99));

        //獲取兩個值中的最大值
        System.out.println(Math.max(20, 30));

        //前面的數是底數,後面的數是指數
        System.out.println(Math.pow(2, 3));             //2.0 ^ 3.0

        //生成0.0到1.0之間的所以小數,包括0.0,不包括1.0
        System.out.println(Math.random());

        //四捨五入
        System.out.println(Math.round(12.3f));
        System.out.println(Math.round(12.9f));

        //開平方
        System.out.println(Math.sqrt(4));
        System.out.println(Math.sqrt(2));
        System.out.println(Math.sqrt(3));
    }

}

14.12_常見對象(Random類的概述和方法使用)

• A:Random類的概述
  
  • 此類用於產生隨機數如果用相同的種子創建兩個 Random 實例，
  • 則對每個實例進行相同的方法調用序列，它們將生成並返回相同的數字序列。
• B:構造方法
  
  • public Random()
  • public Random(long seed)
• C:成員方法
  
  • public int nextInt()
  • public int nextInt(int n)(重點掌握)

package com.heima.otherclass;

import java.util.Random;

public class Demo2_Random {

    /**
     * * A:Random類的概述
            * 此類用於產生隨機數如果用相同的種子創建兩個 Random 實例，
            * 則對每個實例進行相同的方法調用序列，它們將生成並返回相同的數字序列。
        * B:構造方法
            * public Random()
            * public Random(long seed)
        * C:成員方法
            * public int nextInt()
            * public int nextInt(int n)(重點掌握)
     */
    public static void main(String[] args) {
        Random r = new Random();
        /*int x = r.nextInt();

        System.out.println(x);*/

        for(int i = 0; i < 10; i++) {
            //System.out.println(r.nextInt());
            System.out.println(r.nextInt(100));         //要求掌握,生成在0到n範圍內的隨機數,包含0不包含n
        }

        /*
         * -1244746321
            1060493871

            -1244746321
            1060493871

         */
        /*Random r2 = new Random(1001);

        int a = r2.nextInt();
        int b = r2.nextInt();

        System.out.println(a);
        System.out.println(b);*/
    }

}

14.13_常見對象(System類的概述和方法使用)

• A:System類的概述
  
  • System 類包含一些有用的類字段和方法。它不能被實例化。
• B:成員方法
  
  • public static void gc()
  • public static void exit(int status)
  • public static long currentTimeMillis()
  • pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
• C:案例演示
  
  • System類的成員方法使用

package com.heima.otherclass;

public class Demo3_System {

    /**
     * * A:System類的概述
            * System 類包含一些有用的類字段和方法。它不能被實例化。 
        * B:成員方法
            * public static void gc()
            * public static void exit(int status)
            * public static long currentTimeMillis()
            * pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
        * C:案例演示
            * System類的成員方法使用
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        //demo3();

        int[] src = {11,22,33,44,55};
        int[] dest = new int[8];
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }

        System.out.println("--------------------------");
        System.arraycopy(src, 0, dest, 0, src.length);      //將數組內容拷貝

        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }

    public static void demo3() {
        long start = System.currentTimeMillis();        //1秒等於1000毫秒
        for(int i = 0; i < 1000; i++) {
            System.out.println("*");
        }
        long end = System.currentTimeMillis();          //獲取當前時間的毫秒值

        System.out.println(end - start);
    }

    public static void demo2() {
        System.exit(1);                         //非0狀態是異常終止,退出jvm
        System.out.println("11111111111");
    }

    public static void demo1() {
        for(int i = 0; i < 100; i++) {
            new Demo();
            System.gc();                        //運行垃圾回收器,相當於呼喊保潔阿姨
        }
    }

}

class Demo {                                    //在一個源文件中不允許定義兩個用public修飾的類

    @Override
    public void finalize() {
        System.out.println("垃圾被清掃了");
    }                           

}

14.14_常見對象(BigInteger類的概述和方法使用)

• A:BigInteger的概述
  
  • 可以讓超過Integer範圍內的數據進行運算
• B:構造方法
  
  • public BigInteger(String val)
• C:成員方法
  
  • 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)

package com.heima.otherclass;

import java.math.BigInteger;

public class Demo4_BigInteger {

    /**
     ** A:BigInteger的概述
            * 可以讓超過Integer範圍內的數據進行運算
        * B:構造方法
            * public BigInteger(String val)
        * C:成員方法
            * 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)
     */
    public static void main(String[] args) {
        //long num = 123456789098765432123L;
        //String s = "123456789098765432123";

        BigInteger bi1 = new BigInteger("100");
        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]);
        }
    }

}

14.15_常見對象(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)
• D:案例演示
  
  • BigDecimal類的構造方法和成員方法使用

package com.heima.otherclass;

import java.math.BigDecimal;

public class Demo5_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)
        * D:案例演示
            * BigDecimal類的構造方法和成員方法使用
        十進制表示1/3
        0.3333333333333333333333333333333333333333 
             */
    public static void main(String[] args) {
        //System.out.println(2.0 - 1.1);
        /*BigDecimal bd1 = new BigDecimal(2.0);     //這種方式在開發中不推薦,因爲不夠精確
        BigDecimal bd2 = new BigDecimal(1.1);

        System.out.println(bd1.subtract(bd2));*/

        /*BigDecimal bd1 = new BigDecimal("2.0");       //通過構造中傳入字符串的方式,開發時推薦
        BigDecimal bd2 = new BigDecimal("1.1");

        System.out.println(bd1.subtract(bd2));*/

        BigDecimal bd1 = BigDecimal.valueOf(2.0);   //這種方式在開發中也是推薦的
        BigDecimal bd2 = BigDecimal.valueOf(1.1);

        System.out.println(bd1.subtract(bd2));
    }

}

14.16_常見對象(Date類的概述和方法使用)(掌握)

• A:Date類的概述
  
  • 類 Date 表示特定的瞬間，精確到毫秒。
• B:構造方法
  
  • public Date()
  • public Date(long date)
• C:成員方法
  
  • public long getTime()
  • public void setTime(long time)

package com.heima.otherclass;

import java.util.Date;

public class Demo6_Date {

    /**
     * * A:Date類的概述是util包下的,不能導入sql包的
            * 類 Date 表示特定的瞬間，精確到毫秒。 
        * B:構造方法
            * public Date()
            * public Date(long date)
        * C:成員方法
            * public long getTime()
            * public void setTime(long time)
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        Date d1 = new Date();   
        d1.setTime(1000);                               //設置毫秒值,改變時間對象
        System.out.println(d1);
    }

    public static void demo2() {
        Date d1 = new Date();   
        System.out.println(d1.getTime());               //通過時間對象獲取毫秒值
        System.out.println(System.currentTimeMillis()); //通過系統類的方法獲取當前時間毫秒值
    }

    public static void demo1() {
        Date d1 = new Date();                   //如果沒有傳參數代表的是當前時間
        System.out.println(d1);

        Date d2 = new Date(0);                  //如果構造方法中參數傳爲0代表的是1970年1月1日
        System.out.println(d2);                 //通過毫秒值創建時間對象
    }

}

14.17_常見對象(SimpleDateFormat類實現日期和字符串的相互轉換)(掌握)

• A:DateFormat類的概述
  
  • DateFormat 是日期/時間格式化子類的抽象類，它以與語言無關的方式格式化並解析日期或時間。是抽象類，所以使用其子類SimpleDateFormat
• B:SimpleDateFormat構造方法
  
  • public SimpleDateFormat()
  • public SimpleDateFormat(String pattern)
• C:成員方法
  
  • public final String format(Date date)
  • public Date parse(String source)

package com.heima.otherclass;

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

public class Demo7_SimpleDateFormat {

    /**
     * * A:DateFormat類的概述
            * DateFormat 是日期/時間格式化子類的抽象類，它以與語言無關的方式格式化並解析日期或時間。是抽象類，所以使用其子類SimpleDateFormat
        * B:SimpleDateFormat構造方法
            * public SimpleDateFormat()
            * public SimpleDateFormat(String pattern)
        * C:成員方法
            * public final String format(Date date)
            * public Date parse(String source)
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException {
        //demo1();
        //demo2();
        //demo3();

        //將時間字符串轉換成日期對象
        String str = "2000年08月08日 08:08:08";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d = sdf.parse(str);                        //將時間字符串轉換成日期對象
        System.out.println(d);
    }

    public static void demo3() {
        Date d = new Date();                            //獲取當前時間對象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//創建日期格式化類對象
        System.out.println(sdf.format(d));              //將日期對象轉換爲字符串
    }

    public static void demo2() {
        Date d = new Date();                            //獲取當前時間對象
        SimpleDateFormat sdf = new SimpleDateFormat();  //創建日期格式化類對象
        System.out.println(sdf.format(d));              //88-6-6 下午9:31
    }

    public static void demo1() {
        //DateFormat df = new DateFormat();             //DateFormat是抽象類,不允許實例化
        //DateFormat df1 = new SimpleDateFormat();
        DateFormat df1 = DateFormat.getDateInstance();  //相當於父類引用指向子類對象,右邊的方法返回一個子類對象
    }

}

14.18_常見對象(你來到這個世界多少天案例)(掌握)

• A:案例演示
  
  • 需求：算一下你來到這個世界多少天?

package com.heima.test;

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

public class Test2 {

    /**
     * * A:案例演示
     * 需求：算一下你來到這個世界多少天?
     * 分析:
     * 1,將生日字符串和今天字符串存在String類型的變量中
     * 2,定義日期格式化對象
     * 3,將日期字符串轉換成日期對象
     * 4,通過日期對象後期時間毫秒值
     * 5,將兩個時間毫秒值相減除以1000,再除以60,再除以60,再除以24得到天
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException {
        //1,將生日字符串和今天字符串存在String類型的變量中
        String birthday = "1983年07月08日";
        String today = "2088年6月6日";
        //2,定義日期格式化對象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        //3,將日期字符串轉換成日期對象
        Date d1 = sdf.parse(birthday);
        Date d2 = sdf.parse(today);
        //4,通過日期對象後期時間毫秒值
        long time = d2.getTime() - d1.getTime();
        //5,將兩個時間毫秒值相減除以1000,再除以60,再除以60,再除以24得到天
        System.out.println(time / 1000 / 60 / 60 / 24 );
    }

}

14.19_常見對象(Calendar類的概述和獲取日期的方法)(掌握)

• A:Calendar類的概述
  
  • Calendar 類是一個抽象類，它爲特定瞬間與一組諸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日曆字段之間的轉換提供了一些方法，併爲操作日曆字段（例如獲得下星期的日期）提供了一些方法。
• B:成員方法
  
  • public static Calendar getInstance()
  • public int get(int field)

package com.heima.otherclass;

import java.util.Calendar;

public class Demo8_Calendar {

    /**
     * * A:Calendar類的概述
            * Calendar 類是一個抽象類，它爲特定瞬間與一組諸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日曆字段之間的轉換提供了一些方法，併爲操作日曆字段（例如獲得下星期的日期）提供了一些方法。
        * B:成員方法
            * public static Calendar getInstance()
            * public int get(int field)
     */
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();        //父類引用指向子類對象
        //System.out.println(c);                    //證明重寫了toString方法打印了對象中所有的屬性
        System.out.println(c.get(Calendar.YEAR));   //通過字段獲取對應的值
        System.out.println(c.get(Calendar.MONTH));
    }

}

14.20_常見對象(Calendar類的add()和set()方法)(掌握)

• A:成員方法
  
  • public void add(int field,int amount)
  • public final void set(int year,int month,int date)
• B:案例演示
  
  • Calendar類的成員方法使用

package com.heima.otherclass;

import java.util.Calendar;

public class Demo9_Calendar {

    /**
     * * A:Calendar類的概述
            * Calendar 類是一個抽象類，它爲特定瞬間與一組諸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日曆字段之間的轉換提供了一些方法，併爲操作日曆字段（例如獲得下星期的日期）提供了一些方法。
        * B:成員方法
            * public static Calendar getInstance()
            * public int get(int field)
        * C:成員方法
            * public void add(int field,int amount)
            * public final void set(int year,int month,int date)
        * D:案例演示
            * Calendar類的成員方法使用
     */
    public static void main(String[] args) {
        //demo1();
        Calendar c = Calendar.getInstance();            //父類引用指向子類對象
        //c.add(Calendar.MONTH, -1);                    //對指定的字段進行向前減或向後加
        //c.set(Calendar.YEAR, 2000);                   //修改指定字段
        c.set(2000, 7, 8);

        System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 
                + "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
    }

    public static void demo1() {
        Calendar c = Calendar.getInstance();            //父類引用指向子類對象
        //System.out.println(c);
        System.out.println(c.get(Calendar.YEAR));       //通過字段獲取年
        System.out.println(c.get(Calendar.MONTH));      //通過字段後期月,但是月是從0開始編號的
        System.out.println(c.get(Calendar.DAY_OF_MONTH));//月中的第幾天
        System.out.println(c.get(Calendar.DAY_OF_WEEK));//週日是第一天,週六是最後一天

        System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 
                + "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
    }

    /*
     * 將星期存儲表中進行查表
     * 1,返回值類型String
     * 2,參數列表int week
     */

    public static String getWeek(int week) {
        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

        return arr[week];
    }

    /*
     * 如果是個數數字前面補0
     * 1,返回值類型String類型
     * 2,參數列表,int num
     */
    public static String getNum(int num) {
        /*if(num > 9) {
            return "" + num;
        }else {
            return "0" + num;
        }*/
        return num > 9 ? "" + num : "0" + num;
    }
}

14.21_常見對象(如何獲取任意年份是平年還是閏年)(掌握)

• A:案例演示
  
  • 需求：鍵盤錄入任意一個年份，判斷該年是閏年還是平年

package com.heima.test;

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

public class Test3 {

    /**
     * * A:案例演示
     * 需求：鍵盤錄入任意一個年份，判斷該年是閏年還是平年
     * Calendar c = Calendar.getInstance();
     * 
     * 分析:
     * 1,鍵盤錄入年Scanner
     * 2,創建Calendar c = Calendar.getInstance();
     * 3,通過set方法設置爲那一年的3月1日
     * 4,將日向前減去1
     * 5,判斷日是多少天,如果是29天返回true否則返回false
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入年份,判斷該年份是閏年還是平年:");
        //int year = sc.nextInt();

        String line = sc.nextLine();                //錄入數字字符串
        int year = Integer.parseInt(line);          //將數字字符串轉換成數字
        boolean b = getYear(year);
        System.out.println(b);
    }

    private static boolean getYear(int year) {
        //2,創建Calendar c = Calendar.getInstance();
        Calendar c = Calendar.getInstance();
        //設置爲那一年的3月1日
        c.set(year, 2, 1);
        //將日向前減去1
        c.add(Calendar.DAY_OF_MONTH, -1);
        //判斷是否是29天
        return c.get(Calendar.DAY_OF_MONTH) == 29;
    }

}