上海傳智播客JAVASE_day17學習筆記

基本類型包裝類

1、基本類型包裝類介紹

Java中的基本類型：

byte   short   int   long   float   double    char         boolean

主要用來開闢空間存放對應的類型的數據。基本類型的功能十分的單一，主要是負責數據的類型的。

於是java就對這些基本類型也進行對象的封裝，把它們全部都變成對象，可以按照對象的方式來調用它們，並且給它們定義更多的屬性和方法提供給我們使用。

 

基本類型包裝類，它把對應的基本類型都使用一個類來包裝。包裝完之後，我們就可以使用當前這個類來操作對應的基本類型數據。並且給其中封裝更多的行爲。

基本類型包裝類：

byte        short              int             long          float                   double                 char         boolean

Byte     Short          Integer     Long      Float           Double            Character    Boolean

基本類型對應的類類型（包裝類）：其中大部分都是把基本類型的首字母大寫，之後int對應的Integer，char對應的Character

 

Integer:它是對int類型的包裝。其中提供了int類型範圍能夠存放的最大值和最小值的靜態成員變量。

 

基本類型如何變成對應的對象類型

int x = 100;

可以使用Integer中的構造方法

Integer i = new Integer( x ); //x就被包裝成對象類型了

通過保證類型中的方法，把基本類型轉成包裝類型

 

 

包裝類型如何變成對應的基本類型

包裝類型轉成基本類型使用：xxxxValue方法

把字符串轉成對應的基本類型：parseXxxx

 

 

基本類型、對象類型、字符串類型之間的相處轉換

字符串轉成包裝類型：

在使用包裝類型把一個字符串轉成對應的包裝類型時，字符串表示的數據一定要能夠被轉成對應的數據。如果無法轉換就會發生NumberFormatException異常。

 

把基本類型轉成字符串：

使用String類中的valueOf

使用+號連接：123+””;

使用對應的包裝類型中的toString方法

 

 

總結：

基本類型轉對象：使用對象類型的構造方法或使用包裝類型中的valueOf

對象轉基本類型：xxxxValue方法

字符串轉成基本類型：使用包裝類型中的靜態方法parseXxxxx

字符串轉對應的包裝類型：包裝類型的構造方法或者包裝類型中的valueOf

 

2、JDK5的自動裝箱和拆箱

 

publicclass Demo{

    publicstaticvoid main(String[] args) {

        method_2();

    }

    publicstaticvoid method_2() {
        Integer i = new Integer(127);

        Integer i2 = new Integer(127);

        System.out.println(i==i2);

       

        Integer i3 = new Integer(128);

        Integer i4 = new Integer(128);

        System.out.println(i3==i4);

       

        Integer i5 =127;

        Integer i6 =127;

        /*

         * 這裏發生了自動裝箱，在-128到127自動裝箱的時候，jvm在初始化Integer這個類的時候

         * 就已經把-128到127之間這些數據提前存放Integer類型的數組中。

         * 當我們再把-128到127之間的這些數據採用自動裝箱機制賦值給包裝類型時，

         * 不會再創建包裝類型的對象，而是從已經存在的緩存數組中把存在這些對象取出來直接賦值給當前的包裝類型的引用。

         *

         */

        System.out.println(i5==i6);

       

        Integer i7 =128;

        Integer i8 =128;

        System.out.println(i7==i8);

    }

    publicstaticvoid method_1() {

        //把基本類型轉成包裝類型

        intx =123;

        Integer i = new Integer(x);

        Integer ii =Integer.valueOf(x);

        //JDK5之後給了自動裝箱機制，可以把一個基本類型的數據直接賦值給一個對應的包裝類的引用類型

        Integer ii2 = x;  //底層是把x先封裝成Integer對象，然後在把這個對象的地址賦值給ii2

        //早期要把一個包裝類型賦值給基本類型

        Double d = new Double(3.14);

        double dd =d.doubleValue();

        //自動拆箱

        doubledd2 = d;//自動拆箱，會把這個包裝類型拆成對應的基本類型。

        //案例

        Integer i2 = new Integer(3);

       

        Integer i3 = i2 +456;//這裏先把i2拆箱成基本類型，和456進行加法運算，運算的結果又被裝箱成Integer

    }

}

 

 

3、基本類型包裝類練習

/*

 *   需求： 有如下字符串，要求按照其字面值進行排序

 *     "23-2 -1 222 11 10 123 333 33 3"

 *      "23" "-2""-1" "222" "11" "10" "123""133" "33" "3"

 * 思路：

 *     1、首先需要把這個字符串按照空格類切割。切割後會形成一個字符串數組

 *     2、由於需求中要求按照字面值進行大小的排序。需要把這些字符串分別轉成對應的基本類型數據，

 *     3、然後通過基本類型數據對其進行大小的比較。

 *     4、在把字符串數組中的每個字符串轉成對應的基本類型數據，  可以使用Integer類中的parseInt方法

 *         轉後的值也需要存放起來，需要定義一個int數組

 *     5、最後在int數組中的值轉成字符串

 */

publicclass Test{

    publicstaticvoid main(String[] args) {

       

        String s = "23 -2 -1 222 11 10 123 333 33 3";

       

        String[] str_arr = split_method(s);

       

        int[] arr = parse(str_arr);

        //對其進行排序

        Arrays.sort(arr);

       

        String str = arrayToString(arr);

        System.out.println(str);

    }

    //主要負責把一個int數組轉成字符串

    publicstaticString arrayToString(int[] arr) {

        //使用字符串緩衝區把int數組中的每個int值存放到緩衝區中，最後把緩衝區中的所有數據轉成字符串

        StringBuilder sb = new StringBuilder();

        //循環取出arr中的每個int值

        for (inti = 0; i < arr.length; i++) {

            sb.append(arr[i]);

            sb.append(" ");

        }

        String s = sb.toString();

        returns.substring(0,s.length()-1);

    }

    //主要功能是把一個字符串數組轉成對應的int數組，並返回這個int數組

    publicstaticint[] parse(String[] str_arr) {

        //定義一個和字符串數組長度相同的int數組，目的是把字符串數組中的所有字符串都轉成int值存放在int數組中

        int[] arr = newint[str_arr.length];

       

        //取出字符串數組中的每個字符串，然後把其轉成int值，存放在int數組中。

        for ( inti=0;i<str_arr.length;i++ ){

            //取出每個字符串，轉成int值

            arr[i] =Integer.parseInt(str_arr[i]);

        }

       

        returnarr;

    }

    //主要負責把字符串切割成字符串數組

    publicstaticString[] split_method(String s) {

        returns.split(" ");

    }

}

 

其他api類

1、Math類介紹

/*

 * Math類介紹

 * 主要封裝的和數學運算相關的功能。

 * Math類中的方法都是靜態的，可以通過類名直接調用

 *    

 *     ceil(value):返回大於value的最小整數

 *     floor(value):返回小於value的最大整數

 *      round(value):返回四捨五入的值

 *      random() 產生一個僞隨機數，這個數字在0~1之間

 */

publicclassMathDemo {

 

    publicstaticvoid main(String[] args) {

       

        System.out.println(Math.E);

        System.out.println(Math.PI);

       

        System.out.println(Math.ceil(3.54));

        System.out.println(Math.floor(3.54));

        System.out.println(Math.round(3.54));

        System.out.println(Math.random());

        System.out.println(Math.pow(2, 3));

        System.out.println(Math.sqrt(2));

       

    }

}

 

 

2、Random類介紹

/*

 * Random類介紹:

 *     這類是專門負責產生各種各樣的僞隨機數

 * Math類中的random方法，可以產生隨機數。但是這個方法只能產生0~1之間的數據。

 * Random類是負責產生隨機數的，它在java.util.包下

 */

 

publicclassRandomDemo {

    publicstaticvoid main(String[] args) {

        for( inti=0;i<6;i++ ){

            System.out.println((int)(Math.random()* 10));

        }

       

        //使用Random類產生隨機數

        Random r = new Random();

       

        System.out.println(r.nextBoolean());

        System.out.println(r.nextDouble());

        System.out.println(r.nextFloat());

        System.out.println(r.nextInt());

        System.out.println(r.nextInt(6));

    }

}

 

 

 

3、Date類介紹

 

/*
 * Date:
 *     介紹是java.util包下的Date類，這個類是負責描述日期這類數據的。
 *     Date主要是描述當前時間毫秒值對象。
 *     它中的很多方法不利於國際化，已經被廢棄。
 *
 * Date是把當前的毫秒值封裝成Date對象。
 *     如何把一個毫秒值轉成Date對象
 *         Date()它是把當前的時間點的毫秒值轉成Date對象
 *         Date(long date) 把我們指定的一個毫秒值轉成Date對象
 *         setTime(long time) 把當前的Date對象設置成指定的毫秒值對應的那個日期對象
 *        
 *     如何把一個Date對象轉成毫秒值
 *         Date類中有個getTime方法，可以把一個Date對象轉成毫秒值
 */

 

publicclassDateDemo {
    publicstaticvoid main(String[] args) {
        //創建Date對象
        Date d = new Date();
        d.setTime(1380000910915L);
//      Date d = new Date(1380000910915L);
        System.out.println(d);
        System.out.println(d.toGMTString());
        System.out.println(d.toLocaleString());
        System.out.println(d.getTime());

           }

}

 

 

4、DateFormat類介紹

 

   DateFormat類：

        這類位於java.text包下。

        這個類是個抽象類，這個類不能直接new對象。

        DateFormat類主要是把日期對象格式化成字符串數據

            Date對象，通過DateFormat類，可以被格式化成字符串數據"xxxx-xx-xxhh:mm:ss"

        DateFormat類還可以一個字符串數據解析成Date對象。

            "xxxx-xx-xx hh:mm:ss"  解析成Date對象

        格式化：把對象格式化成文本（字符串）

        解析：把文本（字符串）變成對象

   

  由於DateFormat類是抽象類，它不能創建對象，但是這個類對外提供部分的靜態方法，這些方法可以獲取到本類的對象。

        getDateInstance方法有重載，在獲取DateFormat對象的時候可以指定風格

               

        DateFormat.FULL:     2014年8月22日 星期五

        DateFormat.LONG：   2014年8月22日

        DateFormat.MEDIUM：  2014-8-22  是默認風格

        DateFormat.SHORT:    14-8-22

 

  在使用DateFormat類中parse方法來解析一個字符串數據的時候，字符串數據給定的格式必須和獲取DateFormat對象時指定的風格一致，

  這樣才能夠解析，否則解析失敗。

 

 

 

   

//使用DateFormat類把字符串形式的日期數據解析成Date對象
    publicstaticvoid method_2() throwsParseException {
        //字符串形式的日期數據
        String time = "2014年8月22日  星期五";
        //獲取DateFormat對象
        DateFormat df =DateFormat.getDateInstance(DateFormat.FULL );
               //解析字符串
        Date d  = df.parse(time);
        System.out.println(d);
         }
    //使用DateFormat類對日期進行格式化
    publicstaticvoid method_1() {
        //獲取DateFormat對象
        //DateFormatdf = DateFormat.getDateInstance();
        //DateFormatdf = DateFormat.getDateInstance( DateFormat.SHORT );
        DateFormat df =DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM );
        //創建一個Date對象
        Date d = new Date();
        System.out.println(d);
        //對這個Date對象進行格式化
        String time = df.format(d);
        System.out.println(time);

    }

 

 

5、SimpleDateFormat類介紹

 

當我們想按照自己指定的風格來解析字符串數據或者格式化日期對象時，可以使用DateFormat的子類SimpleDateFormat。

 

 

  

/*
     *  演示使用SimpleDateFormat格式化Date對象
     * "xxxx年xx/xxHH時mm分ss秒"
     */
    publicstaticvoid method_4() {
        //獲取Date對象
        Date d = new Date();
        //獲取格式化對象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM/dd HH時mm分ss秒");
        //對日期對象進行格式化
        String time = sdf.format(d);
        System.out.println(time);
    }

    /*
     * 演示使用SimpleDateFormat類解析指定的格式數據
     * "2014/08/22"  對應的格式："yyyy/MM/dd"
     * "2414/08/22 23:23:23"    "yyyy/MM/dd HH:mm:ss"
     */
    publicstaticvoid method_3() throwsParseException {
        //字符串形式的日期數據
        String time = "2414/08/22 23:23:23";
        //創建SimpleDateFormat對象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        //解析
        Date d = sdf.parse(time);
        System.out.println(d);

    }

 

6、日期格式化練習

 

/*
 * 需求：
 *     有2個字符串形式的日期數據，需要計算它們相距多少天？
 *         "2014年09/28 23時13分01秒"
 *         "2009-02月12日 12時02分01秒"
 *
 * 思路：
 * 要計算天數，首先需要把字符串形式的日期數據變成毫秒值，然後再通過毫秒值的相減得到時間差，然後再轉成相距的天數。
 * 如何把字符串數據變成毫秒值呢？
 *     可以通過Date對象中的getTime方法，把一個Date對象轉成毫秒值
 *     把字符串日期數據轉成Date對象，可以使用SimpleDateFormat類完成
 */
publicclassDateTest {
    publicstaticvoid main(String[] args) throwsParseException {
        String s1_time = "2014年09/28 23時13分01秒";
        String s2_time = "2013-09月27日 23時13分01秒";
    
        //獲取格式器
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM/dd HH時mm分ss秒");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM月dd日 HH時mm分ss秒");
      
        //解析字符串
        Date d1 = sdf1.parse(s1_time);
        Date d2 = sdf2.parse(s2_time);
       
        //把當前的日期對象轉成毫秒值
        longtime_1 = d1.getTime();
        longtime_2 = d2.getTime();
      
        longday =(Math.abs(time_1 - time_2))/1000/60/60/24;
        System.out.println(day);
    }
}

 

 

7、Calendar類介紹

 Calendar:

    位於java.util包下。

        這個類主要是用來描述日曆數據。

    Calendar類是個抽象類可以通過getInstance方法獲取其實例。

        它中定義很多靜態成員變量，把日曆上常見的年，月，日，時分秒，星期等數據都封裝成靜態的成員變量，

        可以通過Calendar類直接獲取其對應的數據。

    在計算機中月份從0開始，0表示1月，1表示2月，11表示12月。

   星期也是從0開始，0表示星期日，1表示星期一

  

   我們獲得了Calendar實例之後，就可以通過Calendar類中的get方法獲取當前這個實例中封裝的所有的數據。

   在使用get方法時，需要使用Calendar類本身和其中的靜態成員變量結合使用。

   在Calendar類中有set方法，可以把Calendar實例中的對應的數據修改爲我們想指定的具體年月日時分秒等信息

   add方法可以在指定的成員變量上修改它對應的數據

publicclassCalendarDemo {
    publicstaticvoid main(String[] args) {
        method_2();
    }  
    /*
     * 任意一年的2月有多少天
     *
     * 思路：
     * 獲取一個Calendar實例，然後通過set方法把當前的月份設置爲3月1日。
     * 然後在使用add方法，讓當前的月中的天數-1.這時再去獲取當前的天數，一定是2月的最後一天。
     */
    publicstaticvoid method_2() {
       //獲取Calendar實例
        Calendar c =Calendar.getInstance();
            //使用循環來提供年份
        for( intyear = 1998;year<=2100;year++ ){
            //使用set方法設置當前年月日
            c.set(year, 2,1);
            //使用add方法讓天數-1
            c.add(Calendar.DAY_OF_MONTH, -1);
            System.out.println("當前"+year+"年的2月共計有："+c.get(Calendar.DAY_OF_MONTH));
        }
    }

    //Calendar方法演示
    publicstaticvoid method_1() {
        //獲取Calendar實例
        Calendar c =Calendar.getInstance();
        System.out.println(c.get(Calendar.YEAR));
        //使用set方法來設置年月日
        //c.set(2011,12, 12);
        c.add(Calendar.YEAR, -1);
        System.out.println(c.get(Calendar.YEAR));
    }
}

 

 

8、jdk5可變參數

 

/*
 * 需求：定義功能計算2個數的和值
 *      定義功能計算3個數的和值
 *      定義功能計算4個數的和值
 *     .....
 *
 * 當有多個數據要傳遞給一個方法的時候，最好是把這個數據先封裝到數組中，然後把這個數組直接傳遞給這個方法
 * 那麼在方法中就可以通過數組取出這些數據。
 *
 *
 */

publicclass Demo{
    publicstaticvoid main(String[] args) {
        intsum = getSum(3, 4, 5);
        System.out.println(sum);
         // 定義一個數組
        int[] arr = {2, 3, 4, 5, 6, 7, 8, 9, 10 };
        intsum2 = getSum(2,3,1,4);
        System.out.println(sum2);
        /*
         * 當調用者需要傳遞多個數據給一個功能時，這時可以直接傳遞數據，
         *  這時在定義功能的時候，可以採用jdk5的可變參數機制來接收這些數據
         * 可變參數的格式：
         *      修飾符 返回值類型 方法名 ( 接收的數據類型 ... 變量名 )
         *      { }
         * 可變參數實際是方便了方法的使用者，使用者在調用方法的時候，不需要定義數組，直接傳遞數據即可。
         * 而方法的定義者，在定義功能的時候，需要使用  接收的數據類型 ... 變量名  接收參數
         * 其實方法上的變量名就是數組名
         *
         * 可變參數的細節：
         * 如果一個方法上有可變參數，還有其他的參數，這時可變參數必須寫到整個參數列表的最後
         *  intx, int ... arr
         *   x 接收第一個參數，剩下的參數被arr接收
         */
     }
    // 定義功能，可以接收不確定個數據

    publicstaticint getSum(intx ,int ... arr) {
        intsum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        returnsum;
    }

     /* 定義功能可以接收一個數組，並且能夠計算數組中元素的和值
    public static intgetSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++){
            sum+= arr[i];
        }
        return sum;
    }
    */
    // 計算2個數的和值

    publicstaticint getSum(inti, intj) {
        returni + j;
    }

    // 計算3個數的和值
    publicstaticint getSum(inti, intj, intk) {
        returni + j + k;
    }

    // 計算3個數的和值
    publicstaticint getSum(inti, intj, intk, intt) {
        returni + j + k + t;
    }

}

 

 

 

9、JDK5的foreach循環

/*

 * 高級for循環：

 * 普通for循環格式：

 * for( 表達式1 ; 表達式2 ; 表達式3 ){

 *     循環體

 *  } 

 *  高級for循環的格式：

 *  for( 數據類型   變量名  ： 容器名 ){

 *     循環體

 *  }

 *  數據類型:是容器中存放的數據的類型

 * 

 *  高級for循環主要是用來遍歷容器的。比如數組，這時就可以使用高級for循環來遍歷

 *  for( int x : arr ){

            System.out.print(x+",");

    }

    這個循環其實在底層依然通過下標在訪問arr數組中的數據，只不過是把arr中的數據取出來之後，直接存放在x變量中。

    這時使用高級for循環，我們無法獲取到數組的空間，以及數組的下標，僅僅只能獲取到從數組空間中遍歷出來的那個數據

   

    高級for循環僅僅是用來遍歷容器，如果要對容器中的數據進行復雜的操作，或者修改容器中的數據，這時必須使用普通for循環

 *

 */

publicclassForeachDemo {

    publicstaticvoid main(String[] args) {

       

        int[] arr ={5,1,2,0,8,4,3};

       

        for (inti = 0; i < arr.length; i++) {

            if( i!=arr.length-1 ){

                System.out.print(arr[i]+",");

            }else{

                System.out.println(arr[i]);

            }

        }

        System.out.println("=========================");

       

        for( intx : arr ){

            System.out.print(x+",");

            x =100;

        }

       

        for (inti = 0; i < arr.length; i++) {

            inttemp = arr[i];

            System.out.println(temp+",");

            temp =300;

        }

       

    }

}