黑马程序员-String和正则表达式

最新推荐文章于 2024-10-14 14:50:07 发布

Most_want

最新推荐文章于 2024-10-14 14:50:07 发布

阅读量640

点赞数

文章标签： Java基础正则表达式字符串

本文链接：https://blog.csdn.net/Most_want/article/details/48969555

版权

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！
2015/10/8宿舍
2015 /10/31
2016/3/1

目录：
1. String
2. 字符串缓冲区
3. 正则表达式

1. String类

Java中java.lang包中的String类代表字符串。Java 程序中的所有字符串字面值都作为此类的实例实现。

（1）新建字符串

使用new关键字创建String对象

String str=new String("Java and Heima");

使用字符串常量初始化String变量
```
String str2="Java and Heima";
```

String的常量池

String类比较特殊，它实现了常量池技术。也就是它维护一个内存区域，里面存储String常量。

所以使用字符串常量来赋值，例如上边这条语句的执行顺序是：
A 在常量池中寻找是否存在”Java and Heima”的字符串常量
B 如果有则把它的内存地址返回给String 类引用str2
C 如果没有则创建该String常量，然后再返回内存地址给引用str2：

（2）String类的常见使用
String是基本类型，包含了很多实用方法。

Java其它类型与String类的转换

String类的valueOf静态重载方法提供了把8种基本类型转换为字符串的方法。
例如：

//把int类型整数转换为String类型
String number=String.valueOf(123);
//把char类型转换为String类型
String ch=String.valueOf('c');
//把boolean类型转换为String类型
String flag=String.valueOf(false);

String类的构造方法可以使用byte数组、char数组、int数组等初始化。
getBytes()、toCharArray()两个方法分别可以把String转换为字节数组和字符数组
例如：

// 把字符数组转换为String类型
String charString = new String(new char[] { 'a', 'b', 'c' });

String charString2 = "abc";
// 把String类型转换为字符数组
char[] chs = charString2.toCharArray();

字符串的判断

使用equals方法判断两个字符串的内容是否相同。需要注意==关系运算符比较的是两个字符串的内存地址。

使用contains方法测试当前字符串是否包含指定字符序列
```
boolean flag2=st3.contains("and");
System.out.println(flag2);//true
```
使用indexOf重载方法判断某个字符或字符串在当前字符串中的索引。

//使用indexOf查询自字符串的索引
```
String st3="java and android";
int i=st3.indexOf("an");
```
使用startsWith方法和endsWith方法测试该字符串的前缀和后缀
```
//测试该字符串的前缀
boolean flag3=st3.startsWith("java");
System.out.println(flag3);//true
//测试该字符串的后缀
boolean flag4=st3.endsWith("android");
System.out.println(flag4);//true
```
使用length()获取字符串的长度，使用isEmpty判断当前字符串是否为空字符串。
修改字符串

使用concat方法拼接字符串
例如：
```
String st4="abc";
String st5="def";
String result=st4.concat(st5);
```
替换字符串中出现的某个字符序列

//替换st3中的字符“a”为“A”
```
String result=st3.replace("a", "A");
System.out.println(result);//jAvA And Android
```
分割字符串
//从st3的索引为5的位置开始分割
```
String part=st3.substring(5);
System.out.println(part);//and android
```
使用toLowerCase() 把字符串全部转换为小写，使用toUpperCase()把字符串全部转换为大写

使用trim方法去除字符串两端的空白

（3）针对字符串的格式化操作：

格式化转换：
String line=String.format(“”, )
格式化输出：
System.out.printtf(“”,);

格式说明符语法：
% [参数索引] $[标识] [宽度] . [精度] [转换字符] 或者 % [参数索引]$ [标识] [宽度] [t] [转换字符]

参数索引：
用来定位参数位置。以整数开始，跟在%后面，以美元符号结束。最小值为1,最大值必须小于参数列表中的参数个数。
例如：

//结果对应于参数在参数列表中的位置
System.out.printf("%1$s %3$s %2$s",'a','b','c');//a c b 

//< 相对索引，该标志表示重用以前格式说明符的参数
//第三个格式说明符没有定义参数索引默认从第一个参数开始
System.out.printf("%2$s % < s %s",'a','b','c');//b b a

//格式化小数
System.out.printf("[%.3f ]",123456.12345);//[123456.123 ]
System.out.println();
System.out.printf("[% 12.3f]",123456.12345);[  123456.123]

//此处注意后面只有一个date参数，所以参数索引都设置为1
System.out.printf("当前日期：%tB %< tA %< tH时%< TM分",new Date());//十月 星期二 17时13分

2. 字符串缓冲区

2.1 StringBuffer

String类因为实现了常量池技术，所以一旦创建就不能修改。 StringBuffer类是一个字符串缓冲区，通过某些方法可以修改字符串。

（1）构建字符串缓冲区

创建一个空白的字符串缓冲区，默认容量为16个字符
```
StringBuffer sb1=new StringBuffer();
```
创建一个固定容量的字符串缓冲区
```
StringBuffer sb2=new StringBuffer(16);
```

使用字符串初始化一个字符串缓冲区

StringBuffer sb3=new StringBuffer("java and android");

（2）String和StringBuffer的转换

String到StringBuffer

通过构造器，使用字符串初始化一个字符串缓冲区。

通过append方法，把字符串拼接到缓存区
```
StringBuffer appendStr=new StringBuffer();
appendStr.append("java");   
```
StringBuffer到String

通过构造器，使用字符串缓冲区初始化一个字符串缓冲区。
```
StringBuffer sb3=new StringBuffer("java and android");
String str=new String(sb3);
```
通过toString方法，获取字符串缓存区数据的字符串表示形式。
```
String str2=sb3.toString();
```

（3）字符串的反转

方案1：使用缓冲字符串的反转方法。

    String line=new StringBuilder("abc").reverse().toString();//cba

方案2：把字符串转换为字符数组，然后反向逐个拼接字符数组。

    // 使用字符数组倒序拼接
    public static String reverse2(String line) {
        //把字符串转换为字符数组
        char[] chs = line.toCharArray();
        // 使用高性能的字符串缓冲区拼接
        StringBuilder sb = new StringBuilder();
        // 倒转字符序列并进行拼接
        for (int i = chs.length - 1; i >= 0; i--) {
            sb.append(chs[i]);
        }

        return sb.toString();
    }

方案3：使用递归的方法反向拼接字符串

    // 使用递归
    public static String reverse3(String line) {
        // 递归出口，当子字符串长度为1时直接返回当前字符串本身
        if (line.length() <= 1) {
            return line;
        } else {
            //获取当前字符串长度的中间索引值
            int f = line.length() >> 1;
            //以中间索引值为界限，把当前字符串分割
            String left = line.substring(0, f);
            String right = line.substring(f);
            // 规律，返回两个子字符串的反转字符串
            return reverse3(right).concat(reverse3(left));
        }
    }

2.2 StringBuilder
一个可变的字符序列。StringBuilder与 StringBuffer 兼容，是StringBuffer的替换实现。两者的区别在于StringBuilder不同步，在单线程中使用时比StringBuffer快，但是安全性低。而StringBuffer 与它相反，同步并且安全，但是速度慢。

3. 正则表达式

正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。

（1）语法

字符：
x 字符 x
\ 反斜线字符
\t 制表符
\n 新行（换行）符
\r 回车符

字符类：
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类
\d 数字：[0-9]
\D 非数字： [^0-9]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]

边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界

数量词
X* 出现零次或多次
X+ 出现1次或多次
X？一次或一次也没有
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次

（2）反斜线

作用：
·转义：引用转义构造，比如\n（换行符）,n本身没有其它意思，变为\n后表示换行，这里\把n“转义”了。
·引用：引用其他将被解释为非转义构造的转义字符。比如英文符号的双引号 “” 是转义字符，双引号是字符串的声明符号而并非原本的符号本身，这时候在前面加上反斜线将表示双引号本身。这样声明双引号字符串：String sign=”\”\”“。
（将被解释为非转义构造）意思是\和被引用的转义字符将被解释为其它的意思比如\”将被解释为双引号本身。

注意：
·在不表示转义构造的任何字母字符前使用反斜线都是错误的。
·奇数个数的 \ 可能把 ” 转义，所以会报错。例如：String regex=”\”; 可以这样表示单引号，String regex=”\”“;

（3）群组

(X),X即为群组。
\n,表示第n个群组。
嵌套群组中，根据圆括号从左到右标号，0表示整个表达式。

例如:
匹配连续相同的5个数。

//(\\d)数字的群组，\\n群组选项，{4}数量词，表示前面的字符出现四次
String regex="(\\d)\\1{4}";

（4）贪婪模式

语法：
量词后缀紧跟一个加号。

例如：
“[a-z]+bc”来匹配”abc”，那么[a-z]+这一部分将匹配”abc”，模式剩余部分”bc”将无法被匹配，最终结果将false。

（5）正则表达式的使用
判断：

String regex="\\d{6}";
String line="123456";
//使用regex匹配line
System.out.println(line.matches(regex));//true

分割：

String regex="=";
String line="ab=ab=ab=ab";
String arr[]=line.split(regex);//此处数组将包含四个ab字符串1

3.替换

String regex="java";
String line="abcjavaabcjavaabcjava";
String result=line.replaceAll(regex,"*");
System.out.println(result);//此处运行结果：abc*abc*abc*1

4.获取

Pattern类（正则表达式的编译表达形式）：
public static Pattern compile(String regex) // 将给定的正则表达式编译到模式中
public Matcher matcher(CharSequence input)// 创建匹配给定输入与此模式的匹配器

Matcher类(匹配器类):
public boolean find() //尝试查找与该模式匹配的输入序列的下一个子序列
public String group()//返回由以前匹配操作所匹配的输入子序列

使用步骤：

//正则表达式
String regex="java";
String line="abcjavaabcjavaabcjava";
//创建正则表达式编译对象
Pattern p=Pattern.compile(regex);
//获取匹配器对象
Matcher m=p.matcher(line);
//搜寻是否存在匹配模式的对象字符串
while(m.find()){
    System.out.println(m.group());//获取符合模式的字符串对象
}