Java-009-數組和日期時間類(Date,Calendar)詳解

一、數組

//Java 語言中提供的數組是用來存儲固定大小的同類型元素。

//你可以聲明一個數組變量，如 numbers[100] 來代替直接聲明 100 個獨立變量 number0，number1，....，number99

//①聲明數組變量

        /*
        dataType[] arrayRefVar;   // 首選的方法
        或
        dataType arrayRefVar[];  // 效果相同，但不是首選方法
        */
        //實例
        double[] myListA;         // 首選的方法
        double myListB[];         //  效果相同，但不是首選方法

//②創建數組 使用new操作符來創建數組

        arrayRefVar = new dataType[arraySize];
        /*
        上面的語法語句做了兩件事
        一、使用 dataType[arraySize] 創建了一個數組
        二、把新創建的數組的引用賦值給變量 arrayRefVar。
        */
        //數組變量的聲明，和創建數組可以用一條語句完成
        //dataType[] arrayRefVar = new dataType[arraySize];

        //另外，你還可以使用如下的方式創建數組。
        //dataType[] arrayRefVar = {value0, value1, ..., valuek};
        //數組的元素是通過索引訪問的。數組索引從 0 開始，所以索引值從 0 到 arrayRefVar.length-1。

        //實例
        // 數組大小
        int size = 10;
        //定義數組
        double[] myList = new double[size];
        myList[0] = 5.6;
        myList[1] = 4.5;
        myList[2] = 3.3;
        myList[3] = 13.2;
        myList[4] = 4.0;
        myList[5] = 34.33;
        myList[6] = 34.0;
        myList[7] = 45.45;
        myList[8] = 99.993;
        myList[9] = 11123;
        //計算所有元素的總和
        double total = 0;
        for (int i = 0 ; i < size ; i ++) {
            total += myList[i];
        }
        System.out.println("總和為： " + total);//總和為： 11367.373

//③處理數組

        //數組的元素類型和數組的大小都是確定的，所以當處理數組元素時候，我們通常使用基本循環或者 foreach 循環。
        double[] myListC = {1.9, 2.9, 3.4, 3.5};

        // 打印所有數組元素
        for (int i = 0; i < myListC.length; i++) {
            System.out.println(myListC[i] + " ");
        }
        // 計算所有元素的總和
        double sum = 0;
        for (int i = 0; i < myListC.length; i++) {
            sum += myListC[i];
        }
        System.out.println("Total is " + sum);//Total is 11.7

        // 查找最大元素
        double max = myListC[0];
        for (int i = 1; i < myListC.length; i ++){
            if (myListC[i] > max) max = myList[i];
        }
        System.out.println("Max is " + max);//Max is 4.5

//④foreach 循環 它能在不使用下標的情況下遍歷數組。

        // 打印所有數組元素
        for (double element: myListC) {
            System.out.println("element = " + element);
            /*
                element = 1.9
                element = 2.9
                element = 3.4
                element = 3.5
             */
        }

//⑤數組作為函數的參數 數組可以作為參數傳遞給方法。

 //下面例子調用 printArray 方法打印出 3，1，2，6，4 和 2：
 JavaArray exampleOne =  new JavaArray();
  exampleOne.printArray(new int[]{3, 1, 2, 6, 4, 2});

       public void printArray(int[] array){
        for (int i = 0 ; i < array.length ; i++){
            System.out.print(array[i] + " ");//3 1 2 6 4 2
        }
    }

//⑥數組作為函數的返回值

   public static int[] reverse(int[] list) {
        int[] result = new int[list.length];

        for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
            result[j] = list[i];
        }
        return result;// result 數組作為函數的返回值。
    }

//⑦多維數組

//多維數組可以看成是數組的數組，比如二維數組就是一個特殊的一維數組，其每一個元素都是一個一維數組

        String str[][] = new String[3][4];
        //多維數組的動態初始化（以二維數組為例）
        //1. 直接為每一維分配空間，格式如下：
        //type arrayName = new type[arraylenght1][arraylenght2];
        //type 可以為基本數據類型和復合數據類型，arraylenght1 和 arraylenght2 必須為正整數，arraylenght1 為行數，arraylenght2 為列數。
        int a[][] = new int[2][3];
        //解析：二維數組 a 可以看成一個兩行三列的數組。
        //2. 從最高維開始，分別為每一維分配空間，例如：

        String s[][] = new String[2][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[0][0] = new String("Good");
        s[0][1] = new String("Luck");
        s[1][0] = new String("to");
        s[1][1] = new String("you");
        s[1][2] = new String("!");
       //多維數組的引用（以二維數組為例）
        //對二維數組中的每個元素，引用方式為 arrayName[index1][index2]
        //num[1][0];
       //Arrays 類
        //java.util.Arrays 類能方便地操作數組，它提供的所有方法都是靜態的。
        /*
        具有以下功能：
        給數組賦值：通過 fill 方法。
        對數組排序：通過 sort 方法,按升序。
        比較數組：通過 equals 方法比較數組中元素值是否相等。
        查找數組元素：通過 binarySearch 方法能對排序好的數組進行二分查找法操作。
         */
        /*
        1 public static int binarySearch(Object[] a, Object key)
        用二分查找算法在給定數組中搜索給定值的對象(Byte,Int,double等)。數組在調用前必須排序好的。如果查找值包含在數組中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。
        2 public static boolean equals(long[] a, long[] a2)
        如果兩個指定的 long 型數組彼此相等，則返回 true。如果兩個數組包含相同數量的元素，並且兩個數組中的所有相應元素對都是相等的，則認為這兩個數組是相等的。換句話說，如果兩個數組以相同順序包含相同的元素，則兩個數組是相等的。同樣的方法適用於所有的其他基本數據類型（Byte，short，Int等）。
        3 public static void fill(int[] a, int val)
        將指定的 int 值分配給指定 int 型數組指定范圍中的每個元素。同樣的方法適用於所有的其他基本數據類型（Byte，short，Int等）。
        4 public static void sort(Object[] a)
        對指定對象數組根據其元素的自然順序進行升序排列。同樣的方法適用於所有的其他基本數據類型（Byte，short，Int等）。
         */

二、Java日期時間類

import java.util.Date;
import java.text.*;
import java.util.*;
//java.util 包提供了 Date 類來封裝當前的日期和時間。 Date 類提供兩個構造函數來實例化 Date 對象。

        //1.第一個構造函數使用當前日期和時間來初始化對象。
        //Date()
        //2.第二個構造函數接收一個參數，該參數是從1970年1月1日起的毫秒數。
        //Date(long millisec)
        //Date對象創建以后，可以調用下面的方法。

        //①boolean after(Date date)
        //若當調用此方法的Date對象在指定日期之后返回true,否則返回false。

        //②boolean before(Date date)
        //若當調用此方法的Date對象在指定日期之前返回true,否則返回false。

        //③Object clone( )
        //返回此對象的副本。

        //④int compareTo(Date date)
        //比較當調用此方法的Date對象和指定日期。兩者相等時候返回0。調用對象在指定日期之前則返回負數。調用對象在指定日期之后則返回正數。

        //int compareTo(Object obj)
        //若obj是Date類型則操作等同於compareTo(Date) 。否則它拋出ClassCastException。

        //⑤boolean equals(Object date)
        //當調用此方法的Date對象和指定日期相等時候返回true,否則返回false。

        //⑥long getTime( )獲取時間戳
        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以來此 Date 對象表示的毫秒數。

        //⑦int hashCode( )
        // 返回此對象的哈希碼值。

        //⑧void setTime(long time)
        //用自1970年1月1日00:00:00 GMT以后time毫秒數設置時間和日期。

        //⑨String toString( )
        //把此 Date 對象轉換為以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

//一、獲取當前日期時間

        //1.初始化Date對象
        Date date = new Date();
        //2.使用toString() 函數顯示日期時間
        System.out.println("當前時間" + date.toString());//當前時間Wed Aug 08 09:09:51 CST 2018

//二、日期比較

//Java使用以下三種方法來比較兩個日期
//A.使用 getTime() 方法獲取兩個日期（自1970年1月1日經歷的毫秒數值），然后比較這兩個值。
//B.使用方法 before()，after() 和 equals()。例如，一個月的12號比18號早，則 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
//C.使用 compareTo() 方法，它是由 Comparable 接口定義的，Date 類實現了這個接口。

//三、使用 SimpleDateFormat 格式化日期

        Date dNow = new Date();
        SimpleDateFormat format = new SimpleDateFormat("\"E yyyy.MM.dd 'at' hh:mm:ss a zzz\"");
        System.out.println("CurrentDate : " + format.format(dNow));
        //輸出結果：CurrentDate : "Wed 2018.08.08 at 09:16:51 AM CST"

        //SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
        // 這一行代碼確立了轉換的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是時、分、秒。
        //注意:有的格式大寫，有的格式小寫，例如 MM 是月份，mm 是分；HH 是 24 小時制，而 hh 是 12 小時制。

//四、日期和時間的格式化編碼

        //G     紀元標記     AD
        //y     四位年份     2001
        //M     月份     July or 07
        //d     一個月的日期     10
        //h      A.M./P.M. (1~12)格式小時     12
        //H     一天中的小時 (0~23)     22
        //m     分鍾數     30
        //s     秒數     55
        //S     毫秒數     234
        //E     星期幾     Tuesday
        //D     一年中的日子     360
        //F     一個月中第幾周的周幾     2 (second Wed. in July)
        //w     一年中第幾周     40
        //W     一個月中第幾周     1
        //a     A.M./P.M. 標記     PM
        //k     一天中的小時(1~24)     24
        //K      A.M./P.M. (0~11)格式小時     10
        //z     時區     Eastern Standard Time
        //'     文字定界符     Delimiter
        //"     單引號     `

//五、使用printf格式化日期

//printf 方法可以很輕松地格式化時間和日期。使用兩個字母格式，它以 %t 開頭並且以下面表格中的一個字母結尾。

//c   包括全部日期和時間信息          星期六 十月 27 14:21:20 CST 2007

//F   "年-月-日"格式               2007-10-27

 //D   "月/日/年"格式               10/27/07

//r   "HH:MM:SS PM"格式（12時制）  02:25:51 下午

//T   "HH:MM:SS"格式（24時制）     14:28:16

//R   "HH:MM"格式（24時制）        14:28

        //實例
        // 初始化 Date 對象
        Date dateInfo = new Date();

        //c的使用
        System.out.printf("全部日期和時間信息：%tc%n",dateInfo);
        //全部日期和時間信息：星期三 八月 08 09:23:26 CST 2018

        //f的使用
        System.out.printf("年-月-日格式：%tF%n",dateInfo);
        //年-月-日格式：2018-08-08

        //d的使用
        System.out.printf("月/日/年格式：%tD%n",dateInfo);
        //月/日/年格式：08/08/18

        //r的使用
        System.out.printf("HH:MM:SS PM格式（12時制）：%tr%n",dateInfo);
        //HH:MM:SS PM格式（12時制）：09:23:26 上午

        //t的使用
        System.out.printf("HH:MM:SS格式（24時制）：%tT%n",dateInfo);
        //HH:MM:SS格式（24時制）：09:23:26

        //R的使用
        System.out.printf("HH:MM格式（24時制）：%tR",dateInfo);
        //HH:MM格式（24時制）：09:23

        //如果你需要重復提供日期, 可以利用一個格式化字符串指出要被格式化的參數的索引。
        //索引必須緊跟在%后面，而且必須以$結束
        // 使用toString()顯示日期和時間
        System.out.printf("%1$s %2$tB %2$td, %2$tY",
                "Due date:", dateInfo);//Due date: 八月 08, 2018

        //或者，你可以使用 < 標志。它表明先前被格式化的參數要被再次使用
        // 顯示格式化時間
        System.out.printf("%s %tB %<te, %<tY",
                "Due date:", dateInfo);//Due date: 八月 8, 2018

        //定義日期格式的轉換符可以使日期通過指定的轉換符生成新字符串

        //b的使用，月份簡稱
        String str=String.format(Locale.US,"英文月份簡稱：%tb",date);
        System.out.println(str);
        //2018英文月份簡稱：Aug

        System.out.printf("本地月份簡稱：%tb%n",date);
        //本地月份簡稱：八月

        //B的使用，月份全稱
        str=String.format(Locale.US,"英文月份全稱：%tB",date);
        System.out.println(str);
        //英文月份全稱：August

        System.out.printf("本地月份全稱：%tB%n",date);
        //本地月份全稱：八月

        //a的使用，星期簡稱
        str=String.format(Locale.US,"英文星期的簡稱：%ta",date);
        System.out.println(str);
        //英文星期的簡稱：Wed

        //A的使用，星期全稱
        System.out.printf("本地星期的簡稱：%tA%n",date);
        //本地星期的簡稱：星期三

        //C的使用，年前兩位
        System.out.printf("年的前兩位數字（不足兩位前面補0）：%tC%n",date);
        //年的前兩位數字（不足兩位前面補0）：20

        //y的使用，年后兩位
        System.out.printf("年的后兩位數字（不足兩位前面補0）：%ty%n",date);
        //年的后兩位數字（不足兩位前面補0）：18

        //j的使用，一年的天數
        System.out.printf("一年中的天數（即年的第幾天）：%tj%n",date);
        //一年中的天數（即年的第幾天）：220

        //m的使用，月份
        System.out.printf("兩位數字的月份（不足兩位前面補0）：%tm%n",date);
        //兩位數字的月份（不足兩位前面補0）：08

        //d的使用，日（二位，不夠補零）
        System.out.printf("兩位數字的日（不足兩位前面補0）：%td%n",date);
        //兩位數字的日（不足兩位前面補0）：08

        //e的使用，日（一位不補零）
        System.out.printf("月份的日（前面不補0）：%te",date);
        //月份的日（前面不補0）：8

//六、解析字符串為時間

      //SimpleDateFormat 類有一些附加的方法，特別是parse()，它試圖按照給定的SimpleDateFormat 對象的格式化存儲來解析字符串
        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");

        String input = args.length == 0 ? "2018-8-8" : args[0];

        System.out.print(input + " Parses as ");//2018-8-8 Parses as

        Date t;

        try {
            t = ft.parse(input);
            System.out.println(t);//Wed Aug 08 00:00:00 CST 2018
        } catch (ParseException e) {
            System.out.println("Unparseable using " + ft);
        }

 //七、Java 休眠(sleep)

        //1.sleep()使當前線程進入停滯狀態（阻塞當前線程），讓出CPU的使用、目的是不讓當前線程獨自霸占該進程所獲的CPU資源，以留一定時間給其他線程執行的機會。
        //你可以讓程序休眠一毫秒的時間或者到您的計算機的壽命長的任意段時間。
        try {
            System.out.println(new Date( ) + "\n");
            Thread.sleep(1000*3);   // 休眠3秒
            System.out.println(new Date( ) + "\n");//Wed Aug 08 09:39:54 CST 2018
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }

        //2.如何測量時間間隔（以毫秒為單位）
        try {
            long start = System.currentTimeMillis( );
            System.out.println(new Date( ) + "\n");
            Thread.sleep(5*60*10);
            System.out.println(new Date( ) + "\n");
            long end = System.currentTimeMillis( );
            long diff = end - start;
            System.out.println("Difference is : " + diff);//Difference is : 3005
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }

//八、Calendar類

//設置和獲取日期數據的特定部分呢，比如說小時，日，或者分鍾? 我們又如何在日期的這些部分加上或者減去值呢? 答案是使用Calendar 類

//Calendar類是一個抽象類，在實際使用時實現特定的子類的對象，創建對象的過程對程序員來說是透明的，只需要使用getInstance方法創建即可

        //1.創建一個代表系統當前日期的Calendar對象
        Calendar c = Calendar.getInstance();//默認是當前日期
        //2.創建一個指定日期的Calendar對象
        //使用Calendar類代表特定的時間，需要首先創建一個Calendar的對象，然后再設定該對象中的年月日參數來完成。
        //創建一個代表2009年6月12日的Calendar對象
        Calendar c1 = Calendar.getInstance();
        c1.set(2009, 6 - 1, 12);
        //3.Calendar類對象字段類型
        //Calendar.YEAR    年份
        //Calendar.MONTH    月份
        //Calendar.DATE    日期
        //Calendar.DAY_OF_MONTH    日期，和上面的字段意義完全相同
        //Calendar.HOUR    12小時制的小時
        //Calendar.HOUR_OF_DAY    24小時制的小時
        //Calendar.MINUTE    分鍾
        //Calendar.SECOND    秒
        //Calendar.DAY_OF_WEEK    星期幾

        //4.Calendar類對象信息的設置
        //把 c1對象代表的日期設置為10號，其它所有的數值會被重新計算
        c1.set(Calendar.DATE,10);
        //把c1對象代表的年份設置為2008年，其他的所有數值會被重新計算
        c1.set(Calendar.YEAR,2008);

        //Add設置
        Calendar c2 = Calendar.getInstance();
        //把c2對象的日期加上10，也就是c1也就表示為10天后的日期，其它所有的數值會被重新計算
        c2.add(Calendar.DATE, 10);
        //把c2對象的日期減去10，也就是c1也就表示為10天前的日期，其它所有的數值會被重新計算
        c1.add(Calendar.DATE, -10);

        //Calendar類對象信息的獲得
        // 獲得年份
        int year = c1.get(Calendar.YEAR);
        // 獲得月份
        int month = c1.get(Calendar.MONTH) + 1;
        // 獲得日期
        int dateD = c1.get(Calendar.DATE);
        // 獲得小時
        int hour = c1.get(Calendar.HOUR_OF_DAY);
        // 獲得分鍾
        int minute = c1.get(Calendar.MINUTE);
        // 獲得秒
        int second = c1.get(Calendar.SECOND);
        // 獲得星期幾（注意（這個與Date類是不同的）：1代表星期日、2代表星期1、3代表星期二，以此類推）
        int day = c1.get(Calendar.DAY_OF_WEEK);

//九、GregorianCalendar類

//Calendar類實現了公歷日歷，GregorianCalendar是Calendar類的一個具體實現。

//Calendar 的getInstance（）方法返回一個默認用當前的語言環境和時區初始化的GregorianCalendar對象。GregorianCalendar定義了兩個字段：AD和BC。這是代表公歷定義的兩個時代。

        //下面列出GregorianCalendar對象的幾個構造方法：
        //1     GregorianCalendar()
        //在具有默認語言環境的默認時區內使用當前時間構造一個默認的 GregorianCalendar。
        //2     GregorianCalendar(int year, int month, int date)
        //在具有默認語言環境的默認時區內構造一個帶有給定日期設置的 GregorianCalendar
        //3     GregorianCalendar(int year, int month, int date, int hour, int minute)
        //為具有默認語言環境的默認時區構造一個具有給定日期和時間設置的 GregorianCalendar。
        //4     GregorianCalendar(int year, int month, int date, int hour, int minute, int second)
        //  為具有默認語言環境的默認時區構造一個具有給定日期和時間設置的 GregorianCalendar。
        //5     GregorianCalendar(Locale aLocale)
        //在具有給定語言環境的默認時區內構造一個基於當前時間的 GregorianCalendar。
        //6     GregorianCalendar(TimeZone zone)
        //在具有默認語言環境的給定時區內構造一個基於當前時間的 GregorianCalendar。
        //7     GregorianCalendar(TimeZone zone, Locale aLocale)
        // 在具有給定語言環境的給定時區內構造一個基於當前時間的 GregorianCalendar。

        //這里是GregorianCalendar 類提供的一些有用的方法列表：
        //1     void add(int field, int amount)
        //根據日歷規則，將指定的（有符號的）時間量添加到給定的日歷字段中。
        //2     protected void computeFields()
        //轉換UTC毫秒值為時間域值
        //3     protected void computeTime()
        //覆蓋Calendar ，轉換時間域值為UTC毫秒值
        //4     boolean equals(Object obj)
        //比較此 GregorianCalendar 與指定的 Object。
        //5     int get(int field)
        //獲取指定字段的時間值
        //6     int getActualMaximum(int field)
        //返回當前日期，給定字段的最大值
        //7     int getActualMinimum(int field)
        //返回當前日期，給定字段的最小值
        //8     int getGreatestMinimum(int field)
        // 返回此 GregorianCalendar 實例給定日歷字段的最高的最小值。
        //9     Date getGregorianChange()
        //獲得格里高利歷的更改日期。
        //10     int getLeastMaximum(int field)
        //返回此 GregorianCalendar 實例給定日歷字段的最低的最大值
        //11     int getMaximum(int field)
        //返回此 GregorianCalendar 實例的給定日歷字段的最大值。
        //26     void setTimeZone(TimeZone value)
        //用給定時區值設置當前時區。

        //實例：判斷當前年份是否是閏年
        String months[] = {
                "Jan", "Feb", "Mar", "Apr",
                "May", "Jun", "Jul", "Aug",
                "Sep", "Oct", "Nov", "Dec"};

        int yearF;
        // 初始化 Gregorian 日歷
        // 使用當前時間和日期
        // 默認為本地時間和時區
        GregorianCalendar gcalendar = new GregorianCalendar();
        // 顯示當前時間和日期的信息
        System.out.print("Date: ");
        System.out.print(months[gcalendar.get(Calendar.MONTH)]);
        System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
        System.out.println(yearF = gcalendar.get(Calendar.YEAR));
        System.out.print("Time: ");
        System.out.print(gcalendar.get(Calendar.HOUR) + ":");
        System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
        System.out.println(gcalendar.get(Calendar.SECOND));

        // 測試當前年份是否為閏年
        if(gcalendar.isLeapYear(yearF)) {
            System.out.println("當前年份是閏年");
        }
        else {
            System.out.println("當前年份不是閏年");
            //結果：當前年份不是閏年
        }

//注意：

①Calender的月份是從0開始的，但日期和年份是從1開始的

        Calendar c3 = Calendar.getInstance();
        c3.set(2017, 1, 1);
        System.out.println(c3.get(Calendar.YEAR)
                +"-"+c3.get(Calendar.MONTH)
                +"-"+c3.get(Calendar.DATE));
        //2017-1-1
        c3.set(2017, 1, 0);
        System.out.println(c3.get(Calendar.YEAR)
                +"-"+c3.get(Calendar.MONTH)
                +"-"+c3.get(Calendar.DATE));
        //2017-0-31
        //可見，將日期設為0以后，月份變成了上個月，但月份可以為0

//②把月份改為2試試：

        Calendar c4 = Calendar.getInstance();
        c4.set(2017, 2, 1);
        System.out.println(c4.get(Calendar.YEAR)
                +"-"+c4.get(Calendar.MONTH)
                +"-"+c4.get(Calendar.DATE));
        //2017-2-1

        c4.set(2017, 2, 0);
        System.out.println(c4.get(Calendar.YEAR)
                +"-"+c4.get(Calendar.MONTH)
                +"-"+c4.get(Calendar.DATE));
        //2017-1-28
        //可以看到上個月的最后一天是28號，所以Calendar.MONTH為1的時候是2月

 //③既然日期設為0表示上個月的最后一天，那是不是可以設為負數呢？

        c4.set(2017, 2, 1);
        System.out.println(c4.get(Calendar.YEAR)
                +"-"+c4.get(Calendar.MONTH)
                +"-"+c4.get(Calendar.DATE));
        //2017-2-1

        c4.set(2017, 2, -10);
        System.out.println(c4.get(Calendar.YEAR)
                +"-"+c4.get(Calendar.MONTH)
                +"-"+c4.get(Calendar.DATE));
        //2017-1-18
        //果然可以，所以日期才可以自由加減。
        //月份也可以是負數，規則與日期一樣
        //實測將年份設為非正數時，會自動變為絕對值+1