類型別

引用資料型別存的都是地址，通過地址指向物件；

基本資料型別存的都是具體值；

字串 (String) 型別

• 特點：

  1、字元創都是物件；

  2、一旦初始化，不能被更改，字串緩衝區支援可變的字串，因為 String 物件是不可變的，所以可以共享；

  3、共享；

  eg：

public class Demo06 {
    
    public static void main(String[] args) {
        
        String str = "abcd";
        
        System.out.println("str = " + str);
        
        str = "wxyz";
        
        System.out.println("str = " + str);
        
        String str1 = "啵斯喵";
        String str2 = "啵斯喵";
        
        System.out.println(str1 == str2);       
        /*重點：
            這裡比較的是地址，第一次建立 "啵斯喵" 後建立地址，之後建立先檢視緩衝區種有沒有 "啵斯喵" 
          建立規則：
            有則建立的變數指向此地址，沒有則重新在緩衝區中建立該字元 
        
        */
    }
​
}
​

若使用 new 關鍵字，則比較會出現不同情況

public class Demo07 {
    
    public static void main(String[] args) {
        
        String str1 = "abcd";
        String str2 = new String("abcd");
        
        System.out.println(str1 == str2);           //flase
     // == 比較的是兩個字串的地址，故結果為 false
        System.out.println(str1.equals(str2));      //true
     // equals 方法比較的是兩個字串的值，故結果為true
     // 由上可得：   
     //             字串 String 類中重寫了 equals方法；
        
    }
​
}

字串和 new 字串的區別：

package Demo;
​
public class Demo08 {
    
    public static void main(String[] args) {
​
        String str1 = "abc";
        String str2 = new String("abd");
        
        System.out.println(str1.hashCode());
        System.out.println(str2.hashCode());
        
    }
​
}

• 字串建立過程：

  • 字串 str1 沒有通過 new 關鍵字建立，則主方法壓棧後，在方法區中的常量池中建立常量，主方法中的 String 變數 str1 指向常量池中的地址；

  • 字串 str2 通過 new 關鍵字建立，則主方法壓棧後，在方法區中的常量池中建立常量後，在堆中通過 new 關鍵字來建立 str2 ，並由 str2 指向常量池中的常量，在主方法中，則建立的字串變數 str2 指向堆中開闢的空間的地址；

• String 類的常用基本方法

public class Demo09 {
    
    public static void main(String[] args) {
        /*  字串類的方法：
         *      1.有多少個字元（長度）
         *      2.獲取字元在字串中第一次出現的位置
         *      3.獲取所需位置上的字元
         *      4.獲取部分字串
         *      5.將指定字串替換成另一個字串
         *      6.將字串轉換成位元組陣列或字元陣列
         *      7.字元大小寫互相轉換
         *      8.將字串按照指定方式分割成多個字串
         *      9.字元的比較
         */
        String str = "abcderfgabcdersholgpqweiop";
        
        //1.獲取字串長度
         int length;
         length = str.length();
         System.out.println("字串的長度為：" + length);
         System.out.println("-----------------------------------------");
         
         //2.獲取字元在字串中第一次出現的位置
         int index;
         index = str.indexOf('e');
         System.out.println("字串中字元 e 出現的位置為：" + index);
         
         
         //例項：遍歷字串，找到字串中出現的指定字元的所有位置；
         /*注意：indexOf方法，尋找字串中從 index+1 開始尋找下一次字元 ‘e’ 出現的位置，
                查詢到最後一個位置後，再查詢下一次返回的值就為 -1 ；*/
         while(index != -1){
             System.out.println(index);
             index = str.indexOf('e', index+1);
         }
         System.out.println("-----------------------------------------");
         
         //3.獲取所需位置上的字元
         //注意：String 中字元的位置都是從零開始
         char i ;
         i = str.charAt(2);
         System.out.println("字串中第 2 個字元是：" + i);
         System.out.println("-----------------------------------------");
         
         //4.獲取部分字串
         /*方法：substring(int start,int end);
          * 方法傳入兩個引數，字串的開始下標和結束下標-1,包含頭不包含尾
          * 
          * 方法：substring(int start);
          * 方法傳入一個引數，從字串中的start中開始擷取字元，直到字串擷取結束
          * */
         String temp1,temp2;
         temp1 = str.substring(3, 5);
         System.out.println(temp1);
         temp2 = str.substring(10);
         System.out.println(temp2);
         System.out.println("-----------------------------------------");
         
         boolean aa ;
         aa = str.contains("abc");
         System.out.println(aa);
         System.out.println("-----------------------------------------");
         
         //5.將指定字串替換成另一個字串
         String temp;
         temp = str.replace("abc", "xyz");
         System.out.println(temp);
         System.out.println("2-----------------------------------------");
        
         //6.1將字串轉為字元陣列
         char []ch = str.toCharArray();
         //6.2將字串轉為位元組陣列
         byte []by = str.getBytes();
         for(int y = 0; y < ch.length; y++) {
             System.out.println(ch[y]);
         }
         System.out.println("-----------------------------------------");
         for(int y = 0; y < by.length; y++) {
             System.out.println(by[y]);
         }
         System.out.println("-----------------------------------------");
         
         
         //7.1將字串中的所有字元轉為大寫
         String strtemp ;
         strtemp = str.toUpperCase();
         System.out.println(strtemp);
    System.out.println("-----------------------------------------");

//7.2將字串中的所有字元轉為小寫
String strtem ;
strtem = str.toLowerCase();
System.out.println(strtem);
System.out.println("-----------------------------------------");

//8.將字串按照指定方式分割成多個字串
String []st = str.split("a");
for(int j = 0; j < st.length; j++) {
System.out.println(st[j]);
     }
System.out.println("-----------------------------------------");


//9.字元的比較
/*
      *方法：compare    str1.compare(Str2);
      * 方法返回結果為 str1 中第一個位置上的字元減去 str2 中第一個位置上的字元;
      * 若第一個位置上的字元相同，則比較第二個位置上的字元，以此類推；若 str2 的字元包含 str1 則返回 -1
      */
String a = "a";
String b = "b";

String c = "abc";
String d = "vwx";
String e = "qwertyu";
String f = "mnbvcxz";
System.out.println(a.compareTo(b));
System.out.println(c.compareTo(d));
System.out.println(e.compareTo(f));
    }
​
}

Stringbuffer 和StringBuilder

• 特點：

  • 字串緩衝區（容器）

  • 長度可變

  • 可儲存任意資料型別，內部先將資料轉成字串再儲存

Stringbuffer

• 常用基本方法

  • 構造方法

    public class Demo10 {
        
        public static void main(String[] args) {
            //建立Stringbuffer物件
            StringBuffer Strb1 = new StringBuffer();
            StringBuffer Strb2 = new StringBuffer(5);
            /*  使用建構函式方法過載
             *      Strb1 使用無參構造方法，建立初始容量為 16 的物件；
             *      Strb2 使用有參（int型）構造方法，建立初始容量為 5 的物件；
             *  StringBuffer 若建立的字串緩衝區長度不夠，則自動增加原來一倍的長度
             *  詳情轉至 java-api 查詢
             */
            Strb1.append("helloword");
            Strb1.append(true);
            Strb1.append(1314);
            
            Strb2.append("HELLO");
            
            System.out.println(Strb1);
            System.out.println(Strb2);
    ​
        }
    ​
    }

  • 基本方法

    public class Demo08 {
        
        public static void main(String[] args) {
            //建立Stringbuffer物件
            StringBuffer strb = new StringBuffer("啵斯喵hello");
            
            strb.insert(3,"小哥哥");
            
            System.out.println(strb);       //啵斯喵小哥哥hello
            
            //刪除資料
            strb.delete(3,6);
            System.out.println(strb);       //啵斯喵hello
            
            //修改資料
            strb.replace(3, 8, "你好");
            System.out.println(strb);
            
            //總結：字元的新增刪除，字元位置都是左閉右開
    ​
        }
    ​
    }

     

Stringbuilder

• 方法與 StringBeffer 相通

StringBuffer 與 StringBuilder的異同

基本資料型別和類型別的轉換

• 八種基本資料型別與其物件類

• 基本資料型別 與 類型別 的轉換

 public class Demo11 {
     public static void main(String[] args) {
 //      定義基本資料型別
         char ch = 'a';
         float fo = 1;
         double bl = 520;
         int xt = 1314;
         boolean bb = true;
         byte bt = 10;
         short sh = 11;
         long ll = 5201314;
         
 //      基本資料型別 轉為 類型別
         Character ca = Character.valueOf(ch);
         Float fa = Float.valueOf(fo);
         Double du = Double.valueOf(bl);
         Integer it = Integer.valueOf(xt);
         Boolean bo = Boolean.valueOf(bb);
         Byte be = Byte.valueOf(bt);
         Short so = Short.valueOf(sh);
         Long ln = Long.valueOf(ll);
         
         System.out.println(ca);
         System.out.println(fa);
         System.out.println(du);
         System.out.println(it);
         System.out.println(bo);
         System.out.println(be);
         System.out.println(so);
         System.out.println(ln);
         
 //      類型別 轉為 基本資料型別       
         char cr = ca.charValue();
         float ft = fa.floatValue();
         double dl = du.doubleValue();
         int ii = it.intValue();
         boolean bn = bo.booleanValue();
         byte bd = be.byteValue();
         short st = so.shortValue();
         long lg = ln.longValue();
         
         System.out.println(cr);
         System.out.println(ft);
         System.out.println(dl);
         System.out.println(ii);
         System.out.println(bn);
         System.out.println(bd);
         System.out.println(st);
         System.out.println(lg);
     /*雖然列印輸出一樣，但是類型別的物件可以進行類操作*/    
     }
 ​
 }

• String 字串型別的轉換

 import java.nio.charset.Charset;
 ​
 public class Demo11 {
     public static void main(String[] args) {
         //1. String 型別轉成 int 型別
         System.out.println("99" + 1);
         int a = Integer.parseInt("99")+1;
         System.out.println(a);
         System.out.println("-------------------");
         
         //2. int 型別轉成 String 型別
         System.out.println( 11 + 11 );
         System.out.println( 11 + "" + 11);          //不推薦使用,非專業
         String str1 = String.valueOf(11);           //1.轉為 String 型別
         System.out.println(str1 + str1);
         String str2 = Integer.toString(11);         //2.轉為 String 型別
         System.out.println(str2 + str2);
         System.out.println();
 ​
     }
     
 }

• 包裝類 的裝箱和拆箱

 //類包裝
 public class Demo11 {
     public static void main(String[] args) {
         int a = 9;
         //包裝物件
         Integer i = new Integer(a);
         
         // jdk1.1 之後，簡化書寫       把 int 型別資料轉換為 integer 物件
         Integer j = a;
         //內部實現
         Integer value = Integer.valueOf(a);
         
         
         j = j + 1;
         //1.因為是做加法運算，所以第一步會將 物件 轉為 數值 ----> 自動拆箱 int temp = j.parserint();
         //2.轉為基本數值 j = 9 + 1 結果為 10；
         //3. j 是 Integer 型別，所以賦值之後要自動裝箱
 //      int b = j.intValue() + 1;
 //      Integer.valueOf(b);
         
         System.out.println("================");
         //拓展 ：
 //      在自動裝箱的時候，如果給的數值在 byte 範圍內（-128 到 127），不會建立新記憶體空間而是使用原來已有的空間
         Integer c = new Integer(8);
         Integer d = new Integer(8);
         System.out.println(c == d);                     //false
         System.out.println(c.equals(d));                //true
         
         Integer e = 127;
         Integer f = 127;
         System.out.println(e == f);                     //true
         System.out.println(e.equals(f));                //true
         
         Integer g = 128;
         Integer h = 128;
         System.out.println(g == h);                     //false
         System.out.println(g.equals(h));                //true              
         
     }
 ​
 }
 ​

日期時間類

• 日期時間類

  • 從 jdk 1.1 開始，定義好的 Date 類便由需求的問題，拆分為日期類（Calendar）和時間類（Dateformat）

 import java.text.DateFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
 import java.util.Date;
 ​
 /* 日期類
  * 1、日期轉成字串
  * 2、字串轉成日期
  * 3、SimpleDateFormat 什麼時候用
  * 4、Calendar 什麼時候用 
  * */
 ​
 public class Demo12 {
     public static void main(String[] args) throws ParseException {
         //獲取毫秒值（最小單位：毫秒）        從 1970 年 1 頁 1 日開始
         long time = System.currentTimeMillis();
         System.out.println(time);
         //根據毫秒值獲取物件
         Date d = new Date(time);
         
         System.out.println(d);              //Sat Apr 25 10:46:53 CST 2020
         System.out.println(d.getYear());    //120
         System.out.println(d.getMonth());   //3
         System.out.println(d.getDay());     //6
         System.out.println(d.getDate());    //25
         
         
         //日期類物件轉為字串
         
 //       獲取日期字串擁有的風格：FULL、LONG、MEDIUM 和 SHORT
 //       如何使用對應的風格？ 在getDateInstances 方法中傳入對應的引數
         
         //獲取日期
         DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT);
         String format = df1.format(d);
         System.out.println(format);         
         /* FULL : 2020年4月25日 星期六
          * LONG : 2020年4月25日
          * MEDIUM : 2020-4-25
          * SHORT : 20-4-25
          * */
         
         //獲取時間
         DateFormat df2 = DateFormat.getTimeInstance();
         String format2 = df2.format(d);
         System.out.println(format2);System.out.println("---------------");          
                 
         //獲取日期時間
         DateFormat df3 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
         String format3 = df3.format(d);
         System.out.println(format3);            //2020年4月25日 星期六 上午11時16分22秒 CST
                 
         
         // 日期類
         Calendar c = Calendar.getInstance();
         System.out.println(c);
         /* java.util.GregorianCalendar[time=1587784918491,areFieldsSet=true,
          * areAllFieldsSet=true,lenient=true,
          * zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,
          * useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
          * minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=3,WEEK_OF_YEAR=17,
          * WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=116,DAY_OF_WEEK=7,
          * DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=11,HOUR_OF_DAY=11,MINUTE=21,SECOND=58,
          * MILLISECOND=491,ZONE_OFFSET=28800000,DST_OFFSET=0]
          * */
 //      鍵值對
         System.out.println(c.get(Calendar.DATE));
         System.out.println(c.get(Calendar.YEAR));
         System.out.println(c.get(Calendar.DAY_OF_MONTH));
         System.out.println(c.get(Calendar.DAY_OF_WEEK));
         
         //字串轉日期類物件
         String time0 = "2020-04-25";
         
         //字串的日期風格想要和 DateFormat 相對應才可以進行轉換，否則丟擲異常；
         //如果寫的字串和四種風格不對應，可以使用自定義風格來進行轉換
         DateFormat df0 = DateFormat.getDateInstance();
         Date dt = df0.parse(time0);
         System.out.println("=========================");
         System.out.println(dt);                         //Sat Apr 25 00:00:00 CST 2020
         
         //自定義風格
         String dates = "2020-4-25 12:14:52";
         //給定自定義風格
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:Mm:ss");
         Date ddtt = sdf.parse(dates);
 System.out.println(ddtt);//Sat Apr 25 00:14:52 CST 2020 
    }    
}

&n