Java API类与接口：类的转换方法与正则表达式

文章目录

• • • Java包装类的概述
    • 对应包装类
    • 包装类的转换方法（parse)
    • • Integer.parseInt(String s)
      • Long.parseLong(String s)
      • Byte.parseByte(String s)
      • Short.parseShort(String s)
      • Float.parseFloat(String s)
      • Double.parseDouble(String s)
    • 正则表达式
    • • 常用方法
    • 字符规则
    • • • `.` 匹配除换行符以外的任意单个字符。
        • `[abc]` 匹配方括号内的任意一个字符（如 a 、 b 或 c ）。
        • `[a-z]` 匹配从 a 到 z 的任意一个字符。
        • `[A-Z]` 匹配从 A 到 Z 的任意一个字符。
        • `[0-9]` 匹配从 0 到 9 的任意一个数字。
        • `\w` 匹配任意一个单词字符（等价于 [a-zA-Z0-9_] ）。
        • `\W` 匹配任意一个非单词字符（等价于 [^a-zA-Z0-9_] ）。
        • `\d` 匹配任意一个数字（等价于 [0-9] ）。
        • `\D` 匹配任意一个非数字（等价于 [^0-9] ）。
        • `|` 匹配 | 左右两边的任意一个表达式。
    • 数量规则
    • • • `*`匹配前面的字符零次或多次。
        • `+`匹配前面的字符一次或多次。
        • `?` 匹配前面的字符零次或一次。
        • `{n}` 匹配前面的字符恰好 n 次。
        • `{n,}` 匹配前面的字符至少 n 次。
        • `{n,m}` 匹配前面的字符至少 n 次，最多 m 次。

Java包装类的概述

在Java中，基本数据类型（如 int , char , boolean 等）不是对象，而是一些简单的数据值。

为了能够将这些基本类型作为对象来操作，Java提供了对应的包装类。

这些包装类位于 java.lang 包中，它们是不可变的，即一旦创建了包装类的对象，就不能改变它的值。

对应包装类

• Long - 封装了基本类型 long
• Integer - 封装了基本类型 int
• Short - 封装了基本类型 short
• Byte - 封装了基本类型 byte
• Double - 封装了基本类型 double
• Float - 封装了基本类型 float
• Character - 封装了基本类型 char
• Boolean - 封装了基本类型 boolean

提供额外的方法包装类提供了一系列方法来处理对应的基本类型数据。

存储在集合中由于集合只能存储对象，因此使用包装类可以将基本类型的数据存储在集合中。

包装类的转换方法（parse)

Integer.parseInt(String s)

将字符串参数解析为有符号十进制整数。如果字符串不能被解析，则抛出 NumberFormatException 。

int num = Integer.parseInt("123");
System.out.println("Parsed integer: " + num); //输出: Parsed integer: 123

Long.parseLong(String s)

将字符串参数解析为有符号十进制长整数。如果字符串不能被解析，则抛出 NumberFormatException 。

long num = Long.parseLong("1234567890123456789");
System.out.println("Parsed long: " + num); //输出: Parsed long:
1234567890123456789

Byte.parseByte(String s)

将字符串参数解析为有符号十进制字节。如果字符串不能被解析，则抛出 NumberFormatException 。

byte num = Byte.parseByte("127");
System.out.println("Parsed byte: " + num); // 输出: Parsed byte: 127

Short.parseShort(String s)

将字符串参数解析为有符号十进制短整数。如果字符串不能被解析，则抛出 NumberFormatException 。

short num = Short.parseShort("32767");
System.out.println("Parsed short: " + num); // 输出: Parsed short: 32767

Float.parseFloat(String s)

将字符串参数解析为浮点数。如果字符串不能被解析，则抛出 NumberFormatException 。

float num = Float.parseFloat("123.45");
System.out.println("Parsed float: " + num); // 输出: Parsed float: 123.45

Double.parseDouble(String s)

将字符串参数解析为双精度浮点数。如果字符串不能被解析，则抛出 NumberFormatException 。

double num = Double.parseDouble("123.456789");
System.out.println("Parsed double: " + num); // 输出: Parsed double: 123.456789

正则表达式

正则表达式是一种强大的文本匹配工具，可以用来查找、替换、分割字符串等。

在Java中， String 类也提供了一些直接使用正则表达式的方法，如 matches() 、 split() 、

replaceAll() 等。

常用方法

• matches(String regex): 判断该字符串是否匹配给定的正则表达式。如果整个字符串匹配成功，则返
  回 true ；否则返回 false 。
• split(String regex): 根据给定的正则表达式将字符串分割成一个数组。
• replaceAll(String regex, String replacement): 替换所有匹配给定正则表达式的子字符串。

字符规则

. 匹配除换行符以外的任意单个字符。

a.b 可以匹配 a1b 、 a2b 等。

[abc] 匹配方括号内的任意一个字符（如 a 、 b 或 c ）。

[abc] 可以匹配 a 、 b 或 c 。

[a-z] 匹配从 a 到 z 的任意一个字符。

[a-z] 可以匹配 a 、 b 、 c 等。

[A-Z] 匹配从 A 到 Z 的任意一个字符。

[A-Z] 可以匹配 A 、 B 、 C 等。

[0-9] 匹配从 0 到 9 的任意一个数字。

[0-9] 可以匹配 0 、 1 、 2 等。

\w 匹配任意一个单词字符（等价于 [a-zA-Z0-9_] ）。

\w 可以匹配 a 、 B 、 0 、 _ 等。

\W 匹配任意一个非单词字符（等价于 [^a-zA-Z0-9_] ）。

\W 可以匹配 ! 、 @ 、 # 等。

\d 匹配任意一个数字（等价于 [0-9] ）。

\d 可以匹配 0 、 1 、 2 等。

\D 匹配任意一个非数字（等价于 [^0-9] ）。

\D 可以匹配 a 、 b 、 c 等。

| 匹配 | 左右两边的任意一个表达式。

cat|dog 可以匹配 cat 或 dog 。

数量规则

*匹配前面的字符零次或多次。

a* 可以匹配 a 、 aa 、 aaa 以及空字符串。

+匹配前面的字符一次或多次。

a+ 可以匹配 a 、 aa 、 aaa ，但不匹配空字符串。

? 匹配前面的字符零次或一次。

a? 可以匹配 a 以及空字符串。

{n} 匹配前面的字符恰好 n 次。

a{3} 只能匹配 aaa 。

{n,} 匹配前面的字符至少 n 次。

a{3,} 可以匹配 aaa 、 aaaa 等。

{n,m} 匹配前面的字符至少 n 次，最多 m 次。

a{2,4} 可以匹配 aa 、 aaa 、 aaaa ，但不匹配 a 或 aaaaa 。