JAVA基础--JAVA API常见对象(包装类和正则)12

Posted 2020-10-09 最苦逼的程序猿

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA基础--JAVA API常见对象(包装类和正则)12相关的知识，希望对你有一定的参考价值。

一、基本类型包装类

　　1.基本类型包装类介绍　　　

　　　8种基本类型：

　　 byte short int long float double char boolean

　　这8种基本类型它们在程序仅仅只能规范某个空间的数据类型，并不能按照类的方式去操作这些类型。

　　int a ; 在内存中需要开辟一个int类型的空间，空间名称为a

　　于是sun公司针对这8种基本类型提供了它们各自对应的类类型。把这些类型统一称为基本类型包装类。

　　　byte ------》 Byte

　　　short ------》 Short

　　　int ------》 Integer

　　　long ------》 Long

　　　float ------》 Float

　　　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. 基本类型转成包装类　

　　　　　　1、使用包装类的构造方法

　　　　　　2、使用类中的静态方法valueOf

　　　b. 将包装类型转成基本类型

　　　　使用当前基本类型对应的包装类中的xxxValue方法完成

　　4. 字符串和基本类型数据、包装类型转换

　　　　a.字符串转基本类型　　　　

　　　　　　使用基本类型对应的包装类中的parseXxxx方法。

　　　　b. 基本类型转字符串

　　　　　　b.1 String类中提供的静态的valueOf，可以将基本类型转成字符串

　　　　　　b.2 使用+号链接

　　　　　　b.3 使用包装类中的静态的toString方法

　　　　c. 字符串转包装类型　　　　

　　　　c.1、包装类的构造方法

　　　　c.2、包装类中的静态方法valueOf

　　　　d. 包装类型转字符串　　　

　　　　　　d.1、使用String类中的静态的valueOf方法

　　　　　　d.2、使用包装类中复写了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     }

二、正则表达式

　　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，第二位是可以3、4、5、7、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     }