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     }

　　6. 总结

() 分组，在正则中引用组使用 \\组号，其余地方使用 $组号

{} 声明次数，前面的规则能够出现的次数 {n} 正好n次 {n,} 最少n次 {n,m} 最少n次，最多m次

[] 能够出现的字符列表，在中括号中的内容均可以在字符串的某个位置上出现，但只能出现其中一个

? 当前匹配的字符能够出现零次或一次

* 当前匹配的字符能够出现零次或屡次

+ 当前匹配的字符能够出现一次或屡次

. 当前字符串的位置上能够是任意字符。若是要匹配点，须要使用\\.

\\d [0-9]

\\w [a-zA-Z0-9_]

\\b 单词边界

^ 字符串开始

$ 字符串结束

“^\\w{6,12}$” 在字符串中只能出现[a-zA-Z0-9_] 6到12次