JAVA基礎--JAVA API常見對象(包裝類和正則)

時間 2019-11-10

標籤 java 基礎 api 常見對象包裝正則欄目 Java 简体版

原文原文鏈接

1、基本類型包裝類

　　1.基本類型包裝類介紹　　　

　　　8種基本類型：面試

　　 byte short int long float double char boolean正則表達式

　　這8種基本類型它們在程序僅僅只能規範某個空間的數據類型，並不能按照類的方式去操做這些類型。編程

　　int a ; 在內存中須要開闢一個int類型的空間，空間名稱爲a c#

　　因而sun公司針對這8種基本類型提供了它們各自對應的類類型。把這些類型統一稱爲基本類型包裝類。數組

　　　byte ------》 Byte緩存

　　　short ------》 Shortapp

　　　int ------》 Integerui

　　　long ------》 Long編碼

　　　float ------》 Floatspa

　　　double------》 Double

　　　char -------》 Character

　　　boolean ------》 Boolean

八種基本類型對應的包裝類，除int和char類型以外的其餘六個都是關鍵字的首字母大寫。

　int Integer

　 char Charater

　　2.基本類型包裝類顯示　

　　基本類型對應的包裝類中，提供的成員變量，成員變量中保存當前這個類型中能夠存儲的最大值和最小等靜態變量

　　發現基本類型包裝類沒有對外提供空參數的構造方法。由於每一個基本類型包裝類的對象都須要封裝一個對應的基本類型數值。若是有空參數的構造方法，建立出來的對象並不知道它會將那個基本類型封裝成對象。

1 /*
 2  * 演示基本類型包裝類
 3  */
 4 public class IntegerDemo {
 5     public static void main(String[] args) {
 6         
 7         int x = 123;
 8         //將基本類型數據轉成對應的包裝類型
 9         Integer i = new Integer(x);
10         /*
11          * 在使用基本類型包裝類將一個字符串轉成對應的包裝類對象的時候
12          * 要求指定的字符串中的數據必定能夠轉成數字，若是字符串中存在一個其餘的非
13          * 數字數據，在建立包裝類對象的時候就會發生異常。
14          */
15         Integer i2 = new Integer("123");
16         System.out.println(i2); 
17         //調用成員變量
18         System.out.println(Integer.MAX_VALUE);
19         System.out.println(Integer.MIN_VALUE);
20         System.out.println(i);
21         
22         System.out.println(Integer.toBinaryString(x));
23         System.out.println(Integer.toHexString(x));
24         System.out.println(Integer.toOctalString(x));
25     }
26 }

　　3. 基本數據類型和包裝類之間的轉換

　　　　a. 基本類型轉成包裝類　

　　　　　　一、使用包裝類的構造方法

　　　　　　二、使用類中的靜態方法valueOf

　　　b. 將包裝類型轉成基本類型

　　　　使用當前基本類型對應的包裝類中的xxxValue方法完成

　　4. 字符串和基本類型數據、包裝類型轉換

　　　　a.字符串轉基本類型　　　　

　　　　　　使用基本類型對應的包裝類中的parseXxxx方法。

　　　　b. 基本類型轉字符串

　　　　　　b.1 String類中提供的靜態的valueOf，能夠將基本類型轉成字符串

　　　　　　b.2 使用+號連接

　　　　　　b.3 使用包裝類中的靜態的toString方法

　　　　c. 字符串轉包裝類型　　　　

　　　　c.一、包裝類的構造方法

　　　　c.二、包裝類中的靜態方法valueOf

　　　　d. 包裝類型轉字符串　　　

　　　　　　d.一、使用String類中的靜態的valueOf方法

　　　　　　d.二、使用包裝類中複寫了Object的toString方法

　　　　e. 總結　　　

　　　　　　基本類型、包裝類型、字符串三者之間的轉換：

　　5. 自動裝箱和拆箱

　　　　在JDK5中，針對基本類型數據和對應的包裝類型之間的轉換進行了簡化。

　　　　自動裝箱：能夠把一個基本類型的數據直接賦值給對應的包裝類型的引用。

　　　　自動拆箱：能夠直接把一個包裝類型的引用賦值給基本類型變量。

　　6. 練習

1 /*
 2  * 需求：對字符串中的數字數據按照它們的字面值進行排序。
 3  *         「11  -11  -1  -101  123  21  12  101」
 4  * 分析：
 5  *         須要對字符串進行切割，獲得一個字符串數組，這時不能直接對這個對象進行排序
 6  *         由於直接排序是按照數組中每一個字符串的相同位置上字符的編碼值進行大小比較
 7  *         而不能按照每一個字符串中的數字具體數值進行比較
 8  * 
 9  *         咱們就須要將當前的字符串數組中的每一個字符串再轉成int類型的數字，而後在比較大小排序
10  */
11 public class Test {
12     public static void main(String[] args) {
13         
14         String s ="11 -11 -1 -101 123 21 12 101";
15         
16         //使用空格切割
17         String[] strs = s.split(" ");
18         
19         //定義一個int類型的數組，用於保存轉後的每一個int數據
20         int[] arr = new int[strs.length];
21         
22         //循環取出字符串數組中的每一個字符串數據
23         for (int i = 0; i < strs.length; i++) {
24             //將字符串轉成int值保存在arr數組中
25             int x = Integer.parseInt(strs[i]);
26             arr[i] = x;
27         }
28         //循環結束，就表示當前strs數組中的每一個字符串都已經被轉成int類型的數據保存在arr中
29         //對arr排序
30         Arrays.sort(arr);
31         
32         //將數組轉成字符串
33         //使用字符串緩衝區，臨時將須要拼接的數據存儲在緩衝區中
34         StringBuilder sb = new StringBuilder();
35         //循環取出arr中的每一個int類型的數據
36         for (int i = 0; i < arr.length; i++) {
37             sb.append(arr[i]);
38             sb.append(" ");
39         }
40         
41         //將字符串緩衝區中的數據轉成字符串數據
42         String ss = sb.toString();
43         
44         System.out.println(ss);
45     }
46 }

　　7.面試題

1 /*
 2  * 面試題
 3  *  
 4  *  在Integer類中定義了成員內部類IntegerCache
 5  *  在這個內部類中有一個靜態代碼塊，這個代碼塊中建立了
 6  *  Integer類型的數組，共計有256個空間，
 7  *  緊接着使用循環給Integer數組進行初始化。
 8  *  將-128到127之間的256個數字已經封裝成Integer對象存放在數組中。
 9  *  
10  *  只要在程序中使用到的Integer類，就會自動的加載內部類IntegerCache。
11  *  內部類中就會將上述-128到127已經存儲在數組中。
12  *  咱們在程序中須要使用-128到127之間的Integer類型的數據時，
13  *  這時JVM不會再將咱們制定的這些數據封裝成對象，而是到IntegerCache內部維護的那個數組中
14  *  找到-128到127之間已經存在的這個對象，將這個對象的地址賦值給咱們的程序中的引用變量。
15  *  
16  */
17 public class Test {
18     public static void main(String[] args) {
19         
20         //下面兩行代碼，其實並無單獨的去封裝Integer對象，而是找緩存中的對象
21         Integer i = -128;
22         Integer i2 = -128;
23         //下面兩行代碼，指定的數據由JVM單獨去封裝成Integer對象
24         Integer i3 = -129;
25         Integer i4 = -129;
26         
27         System.out.println(i == i2);  //true
28         System.out.println(i3 == i4); //false
29         
30         Integer i5 = new Integer(127);
31         Integer i6 = new Integer(127);
32         System.out.println(i5 == i6);  //false
33         
34     }

2、正則表達式

　　1. 正則引入　　

需求：驗證輸入的QQ號碼是否正確

1 /*
 2  * 需求：驗證輸入的QQ號碼是否正確
 3  * 
 4  * 分析：
 5  *       QQ號碼是純數字組成
 6  *    QQ的長度5 到  12 位之間  
 7  *    QQ號碼不能以 0 開始
 8  *    
 9  */
10 public class QQCheckDemo {
11     public static void main(String[] args) {
12         
13         //獲取錄入的QQ號碼
14         Scanner sc = new Scanner(System.in);
15         System.out.println("請輸入您的QQ號碼：");
16         String qq = sc.nextLine();
17         
18         //驗證長度
19         if( qq.length() >= 5 && qq.length() <= 12 ){
20             
21             //驗證是否以零開始
22             if( !qq.startsWith("0") ){
23                 /*
24                  * 驗證是純數字
25                  * 將表示QQ號碼的字符串轉成數字，若是字符串中所有是數字
26                  * 必定能夠轉成一個整數，若是有其餘的數字，轉換就會發生異常
27                  */
28                 try{
29                     long qq_num = Long.parseLong(qq);
30                     System.out.println("QQ號碼正確");
31                 }catch( NumberFormatException e ){
32                     //e.printStackTrace();
33                     System.out.println("QQ號碼必須是純數字組成！！！");
34                 }
35             }else{
36                 System.out.println("QQ號碼不能以零開始！！！");
37             }
38         }else{
39             System.out.println("QQ號碼長度有誤！！！");
40         }
41         
42         //演示使用正則驗證QQ號碼
43         boolean b = qq.matches("[123456789][0-9]{4,11}");
44         System.out.println(b);
45     }
46 }

　　2.正則表達式介紹

　　　　2.1 正則表達式概念　　　　　

　　　　　　在程序中常常須要對字符串這類數據進行合法性的驗證，若是沒有其餘的新技術，就只能採用字符串中的原始方法進行截取等各類的判斷，這樣代碼書寫量大，而且不利於程序的維護。

　　　　　　因而就提供了更加簡便的技術來驗證碼字符串這類數據。這個技術就是正則表達式。

　　　　　　正則表達式：正確的規則組成的一個表達式，它能夠去驗證其餘的字符串數據合法性。

　　　 2.2 正則表達式的書寫規則　　　　

　　　　　正則表達式是驗證字符串：在正則表達式中書寫的規則是限定字符串中不一樣位置上能夠出現哪些字符數據。

　　　　　正則的書寫：正則表達式的體現也是字符串。

須要驗證的字符串數據：」abc」條件是：字符串第一位上只能書寫小寫字母a

字符串第二位上能夠書寫 b 或者 c

字符串第三位上c或d或e

正則表達式書寫：」a[bc][cde]」

正則表達式的第一位上書寫規則是用來驗證字符串中第一位上能夠書寫的字符數據

解釋正則表達式中[]的用法：書寫[] 中的內容，是用來驗證字符串中某個位置上能夠書寫的字符數據

字符串數據：」13499990000」

正則表達式：」1[34578][0-9]」驗證前三位

解釋正則表達式中{} 的用法：

X{N} X表達式的是正則的規則，後面的{N} 表達式的是前面的正則規則所在位置日後能夠出現的次數

字符串數據：」13499990000」

正則表達式：」1[34578][0-9]{9}」這個規則規定須要被驗證的字符串中的第一位只能數字1，第二位是能夠三、四、五、七、8中的任何一個，從第三位開始能夠是0-9中的任何一個，一直到第11位。

X? X依然是正則的規則，？表達式的是X這個規則能夠出現零次或一次

X* X依然是正則的規則，*表達式的是X這個規則能夠出現零次或者屢次

X+ X依然是正則的規則，+表達式的是X這個規則能夠出現一次或者屢次

字符串數據：」abc「

正則規則：」a?」

字符串數據：」abcABC」

正則規則：」.bcABC」說明：當前的正則規定的字符串的第一位上能夠是任何的字符數據

字符串數據：」13499990000」

正則表達式：」1[34578]\\d{9}」

. 表示任意字符數據

\d 表示數字字符

\w 表示字母數字下劃線（注意：沒有 $ 符號）

　　3.正則演示

1 /*
 2  * 驗證手機號碼 ，使用正則表達式
 3  */
 4 public class TelNumberCheck {
 5     public static void main(String[] args) {
 6         
 7         //定義正則規則
 8         String regex = "1[34578][0123456789]\\d{8}";
 9         
10         String tel = "13345678901";
11         
12         //驗證
13         boolean b = tel.matches(regex);
14         //System.out.println(b);
15         if( b ){
16             System.out.println("手機號碼正確");
17         }else{
18             System.out.println("手機號碼有誤");
19         }
20         
21     }
22 }

　　4. 正則經常使用功能介紹

　　　　4.1匹配功能　　　

　　　　　　a. 使用String類中的matches方法完成：　　

1 /*
 2  * 簡單驗證身份證號碼正確性
 3  */
 4 public class IDCardCheck {
 5     public static void main(String[] args) {
 6         
 7         //須要被驗證的字符串數據
 8         String idCard = "11012219901212567X";
 9         //正則的規則
10         String regex = "[1-9][0-9]{5}[12][0-9]{3}[01][0-9][0123][0-9]\\d{3}[0-9Xx]";
11         
12         //調用String類中的匹配方法驗證
13         boolean b = idCard.matches(regex);
14         System.out.println(b);
15     }
16 }

　　　　　　2. 切割功能

1 // 切割，使用點切割
 2     public static void method2() {
 3 
 4         // 須要被切割的字符串數據
 5         String s = "abc....qwe..jk.........2322...22bcd.....3324";
 6 
 7         /*
 8          * 因爲點(.)在正則中有特定的含義，若是在程序中須要使用點自己
 9          * 就須要使用轉義字符表示點
10          */
11         String regex = "\\.+";
12 
13         String[] strs = s.split(regex);
14 
15         for (int i = 0; i < strs.length; i++) {
16             System.out.println(strs[i]);
17         }
18     }
19 
20     // 使用正則切割字符串
21     public static void method() {
22 
23         // 須要被切割的字符串數據
24         String s = "abc qwe jkl    123   3432    324";
25 
26         // 書寫正則規則
27         String regex = " +";
28 
29         String[] strs = s.split(regex);
30 
31         for (int i = 0; i < strs.length; i++) {
32             System.out.println(strs[i]);
33         }
34     }

　　　　　　3. 正則中的組

　　　　　　疊詞：就是重複的詞

1 // 切割，要求按照不一樣的疊詞進行切割
 2     public static void method3() {
 3 
 4         // 須要被切割的字符串數據
 5         String s = "abc##qwe###jklllll1232222bcd####abcccc3440123324";
 6         /*
 7          * 使用不一樣的疊詞切割，因爲不知道具體使用的是哪一個疊詞 
 8          * 字符串中的任何字符都有可能重複，這些字符都有可能做爲切割的標準
 9          * 
10          * 咱們不知道具體是哪一個字符在重複，所以只能使用正則中的點(.)表示被切割的那個字符 .是表示任意字符
11          * 只要這個字符重複了，就使用它做爲切割標準。
12          * 
13          * 只要當前這個點匹配上了這個字符，就必需要求這個字符後面的 位置還要是這個字符
14          * 解決上述的這個問題：須要將已經匹配上的正則規則在當前這個位置的後面繼續使用
15          * 這時就須要將這個規則封裝成正則中的組，而後在後面的位置上使用這個組
16          * 
17          * 正則中的組的書寫格式：
18          *     "(正則規則)後面就可使用前面小括號中封裝好的規則"
19          * 若是須要在當前這個正則中引用前面已經存在的組，格式是：
20          *     \\組號
21          * 正則中只要使用小括號，就表明將某個規則封裝成一個組，每一個組都有本身默認的編號
22          * 正則中的組的編號從1開始，只要出現一個組，編號就自動+1.
23          * 
24          * 例如："(.)\\1"  先使用這個正則規則去匹配某個字符串中的第一個位置，若是匹配上以後
25          *     要求被匹配的第二個位置上的內容必須和第一個位置上的內容徹底一致 
26          * 
27          * ((A)(B(C)))  共計有4個組：
28          *     第一組：((A)(B(C))) 1
29          *  第二組：(A)  2
30          *  第三組：(B(C))  3
31          *  第四組：(C)  4
32          * 開發中儘可能不要使用組或者是組的嵌套。
33          * 
34          */
35         String regex = "(.)\\1+";
36 
37         String[] strs = s.split(regex);
38 
39         for (int i = 0; i < strs.length; i++) {
40             System.out.println(strs[i]);
41         }
42     }

　　　4. 替換功能

1 /*
 2  * 使用正則替換字符串中的數據
 3  */
 4 public class ReplaceDemo {
 5     public static void main(String[] args) {
 6         method4();
 7     }
 8     //正則替換練習
 9     public static void method4() {
10         //將下面的字符串中的數據 替換成「我要學Java編程」
11         String s = "我我我我.......要要要要要要....學學學學學.......Java...編.....程程程程程程";
12         //先把字符串中的全部點幹掉
13         String s2 = s.replaceAll("\\.+", "");
14         System.out.println(s2);
15         //將不一樣的疊詞替換成一個
16         String s3 = s2.replaceAll("(.)\\1+", "$1");
17         System.out.println(s3);
18         
19     }
20     //使用正則的替換功能將手機號碼中間四位替換成****
21     public static void method3() {
22         
23         String tel = "13412345678";
24         //書寫正則規則
25         String regex = "(1[34578][0-9])(\\d{4})(\\d{4})";//分組 根據小括號分組 分紅三組
26         
27         String string = tel.replaceAll(regex, "$1****$3");//第一組和第三組是什麼仍是什麼 第二組替換成*
28         
29         System.out.println(string);
30     }
31 
32     // 將字符串中的多個不一樣的疊詞替換中一個疊詞
33     public static void method2() {
34 
35         String s = "ssjddklffffjsklddddjfkkkkklsdjflllllksd";
36 
37         /*
38          *  書寫正則規則
39          *  
40          *  若是在一個正則表達式中，已經存在了組，在本正則中使用存在的組
41          *  直接使用\\組號的方式引用。
42          *  若是不在本正則表達式中引用正則中的組，須要使用$組號
43          */
44         String regex = "(.)\\1+";
45 
46         String new_str = s.replaceAll("(.)\\1+", "$1");
47         System.out.println(new_str);
48 
49     }
50 
51     // 將多個#號 替換成一個#號
52     public static void method() {
53         // 須要被替換的字符串
54         String s = "sjk####lfj###sdk#######ljfk####ld##sj";
55 
56         // 書寫正則規則
57         String regex = "#+";
58 
59         String new_str = s.replaceAll(regex, "#");
60         System.out.println(new_str);
61     }
62 }

　　5. 獲取功能

需求：從一個字符串中提取出指定的數據內容。

「sdjflkskj13234561234djfue1349876543rieje18800008888irtircnvhdslflsdjfl」

正則表達式它在Java中它屬於字符串，可是這類字符串數據又具有了其餘的功能。Java將正則表達式這類數據又從新封裝一個類，使用這個類表示正則表達式這類事物（數據）。

在Java中Pattern這個類表示正則表達式這類事物。

Pattern類沒有對外提供公開的構造方法，所以咱們不能直接經過new關鍵字建立Pattern對象。

當獲取到正則對象以後，若是須要經過這個正則對象去操做字符串數據，這時必須將正則和字符串進行組合，而後獲得一個專業的匹配器對象。

獲得正則對象以後，須要使用其中的matcher方法將正則對象和字符串關聯（組合），就會獲得一個匹配器對象Matcher。

咱們須要獲取、切割、替換字符串中的數據時，就須要經過Matcher對象完成。

1     public static void method() {
 2         //書寫正則表達式
 3         String regex = "1[34578]\\d{9}";
 4         
 5         //將正則表達式轉成正則對象
 6         Pattern pattern = Pattern.compile(regex);
 7         
 8         //指定須要操做的字符串數據
 9         String s = "lk123skj13234561234djfuieje18800008888irtifl";
10         
11         //將字符串和正則對象進行組合
12         Matcher matcher = pattern.matcher(s);
13         
14         //使用匹配器獲取正則匹配上的數據內容
15         while( matcher.find() ){
16             System.out.println(matcher.group());
17         }
18     }