正则表达式以及字符串String类

时间:2021-10-17 15:29:11

所谓的正则表达式就是符合一定规则的表达式

   作用   :  用于专门操作字符串的

   特点   :  用一些特点的符合来表示一些代码操作   这样奇偶简化书写

所以学习正则表达式奇偶是在学习一些 特殊符号的使用

   好处   :  可以简化对字符串的复杂操作

   弊端   :  符号定义越多 正则越长   阅读性极差

常用的规则有

预定义字符类 
. 任何字符(与行结束符可能匹配也可能不匹配) 
\d 数字:[0-9] 
\D 非数字: [^0-9] 
\s 空白字符:[ \t\n\x0B\f\r] 
\S 非空白字符:[^\s] 
\w 单词字符:[a-zA-Z_0-9] 
\W 非单词字符:[^\w] 


字符类 
[abc] a、b 或 c(简单类) 
[^abc] 任何字符,除了 a、b 或 c(否定) 
[a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内(范围) 
[a-d[m-p]] a 到 d 或 m 到 p:[a-dm-p](并集) 
[a-z&&[def]] d、e 或 f(交集) 
[a-z&&[^bc]] a 到 z,除了 b 和 c:[ad-z](减去) 
[a-z&&[^m-p]] a 到 z,而非 m 到 p:[a-lq-z](减去) 




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


边界匹配器 
^ 行的开头 
$ 行的结尾 
\b 单词边界 
\B 非单词边界 
\A 输入的开头 
\G 上一个匹配的结尾 
\Z 输入的结尾,仅用于最后的结束符(如果有的话) 
\z 输入的结尾 


组和捕获 
捕获组可以通过从左到右计算其开括号来编号。例如,在表达式 ((A)(B(C))) 中,存在四个这样的组: 


1     ((A)(B(C))) 
2     \A 
3     (B(C)) 
4     (C) 


演示局部功能:

1 匹配  String类中的 maches()方法

用于规则匹配整个字符串  只要有一次不符合规则 那么就匹配结束  返回false

public static void ss()
{
String s="badac 234";
String guizhe="[a-z][abc][^abc][a-zA-Z][a-c[w-z]]\\s\\d{3}";/*这是一个规则每一个中括号只能规则一个字符 第一个[]中括号只能规则的意思是 
只能规则小写a-z之间的字符  第二个中括号只能是abc  第三个中括号除了小写abc其他字符都可以  
第四个中括号的意思是只能是小写或者大写a-z A-Z  第5个中括号嵌套这中括号  第六个\\s是空白字符
第七个\\d{3}的意思是  只能是数字  只能有3位
这个嵌套的中括号的规则是  只能是小写a到c之间 或者 是w-z之间
如果都满足就就为真 否则为假*/
boolean zj=s.matches(guizhe);
System.out.println(zj);
}

2 切割  String类中的split ()方法

public static void ss()
{
String s="asddsdjjwlffcpvs";
String gz="(.)\\1+";//封装成组  可以这样理解 点.是取一个字符 1 取下一个 然后拿点.那个来跟1那个比较是否一样
//如果不一样就继续往下取
String []str=s.split(gz);
for (String a:str)
{
System.out.println(a);
}
}

3 替换 String中的replaceAll()方法

public static void ss1()
{
String s="asddddsdjjwlffcpvs";
String str=s.replaceAll("(.)\\1+","$1");/*意思是点.是任意字符 把它封装成一个组
然后\\1+是取下一个或者多个判断有没有跟点.字符是一样的
如果相邻旁边有一个或者多个  那么 参数2的 $1就会取组的字符
当前是第一组  第一组是什么字符就替换成什么字符*/

System.out.println(str);
}


4 获取  将字符串中的符合规则的子串取出

操作步骤:

1 将正则表达式封装成对象

2 让正则表达式和要操作的字符串相关联

3 关联后 获取正则表达式引擎

4 通过引擎对符合规则的子串进行操作  比如取出

public static void ss3()
{
String s="da jia hao wo de ming zi jiao zuo guo wei haha";
String guizhe="\\b[a-z]{3}\\b";//规则
Pattern p=Pattern.compile(guizhe);//把规则封装成对象
Matcher m=p.matcher(s);          //获取引擎
//System.out.println(m.matches());
while (m.find())//判断下一个有没有   类似于迭代器中的hasNext
{
System.out.println(m.group());  //类似于next  取出
}
}


String  类:

字符串是一个特殊的对象 

        在现实中很常见  比如发帖  QQ聊天

字符串一旦初始化就不可以被改变

String str="abc" str是一个类类型变量   “abc”是一个对象 

        String str1=new String("abc");这种跟上面那种方式是一样的

不同的是 地址不一样 值一样  值一样的原因是因为 String复写了Object类中的equals 方法

str有一个对象  str1有两个对象  new 是一个对象 “abc”又是一个对象所以有两个对象

建立了自己特有的方法  这个方法是比较值是否一样  而 Object中的equals 是比较地址

String常用的方法有:

1 获取
返回int  indexOf(String a)找字符串中第一次出现的位置,如果没有返回-1
    int  indexOf(int ch)找字符中出现的位置,如果没有返回-1
    int  indexOf (int ch,int a)从指定位置开始找 ,如果没有返回-1
    int  lastIndexOf(int ch) 反向找
    int  lastIndexOf(int ch,int a)从指定位置反向找
    char charAt(int a)返会指定字符某个位置的字符 当访问到字符串不存在的角标时就会发生角标越界异常


2 判断 
boolean startsWith(String a)判断字符串是否以指定的内容开头
boolean endsWith(String a)判断字符串是否以指定的内容结束
boolean isEmpty()判断字符串是否为空
boolean contains(char)判断字符串是否包含某个字符
boolean equals(String a)判断字符串内容是否相同
boolean equalsIgnoreCase(String a)判断字符串内容是否相同 并且忽略大小写


3转换
1 将字符数组转成字符串
  构造函数 String(char[])
                    String (chat[],offset,count)将字符数组中的一部分转成字符串
  静态方法 static String copyValueOf(chat[] data)
   static String copyValueOf (chat[] data,int a,int b)将字符数组中的一部分转成字符串
2 将字节数组转成字符串
  String(byte[])
           String (byte[],offset,count)将字节数组中的一部分转成字符串
        3 将字符串转换成字符数组
chat[] toCharArray() 
4 将字符串转换成字节数组
byte[] getBytes()
5 将基本数据类型转成字符串
static String valueof(int)
static String valueof(double)
6 对字符串转成大写或者小写
String toUpperCase()
String toLowerCase()
7 对字符串两端的多个空格去除
String trim()
8 对两个字符串进行自然顺序的比较 比的是ikc码
int compareTo(String);
4 替换
String replace(oldchar,newchar)


5 切割
String[] split(regex) regex 拿什么作为切割符  


6 子串 获取字符串中的一部分

String substring(int begin)
String substring (int begin,int end)


代码演示:

class wanwan
{
public static void aa()//1.0查找
{
String s="abccdeadeef";
sos(s.indexOf('b'));//找字符出现的字符串的第一个位置索引
sos(s.indexOf("cde"));//找字符串在字符串出现的第一个位置索引
sos(s.indexOf('d',2));//从指定的位置找字符出现在字符串出现的第一个位置
sos(s.lastIndexOf('e'));//反向找字符出现在字符串的第一个位置
sos(s.lastIndexOf('e',6));//反向找字符出现在字符串的第一个位置 指定位置找
sos(s.lastIndexOf("cc",8));//反向找字符串出现在字符串的第一位置 指定找
//以上的没有找到都返回-1
}
public static void bb()//1.1查找
{
String a="abcdefg";
sos(a.charAt(3));//查找字符串的某个位置的字符
//StringIndexOutOfBoundsException 如果没有或出现越界异常
}


public static void cc()//2 判断
{
String a="abcde.java";
String b="abcde.java";
String c="ABCDE.java";
sos(a.isEmpty());//判断字符串是否为空
sos(a.startsWith("abc"));//判断字符串是否以前缀开头
sos(a.endsWith(".java"));//判断字符串是否以后缀结尾
sos(a.contains("de"));//判断字符串是否包含某一个字符
sos(a.equals(b));//判断字符串是否相同
sos(a.equalsIgnoreCase(c));//判断字符串是否相同 并忽略大小写

}
public static void dd()//转换
{
char [] a={'a','b','c','d','e','f'};
String b=new String(a,2,4);//构造函数// 将字符数组转换成字符串 2是起始位4是个数
sos(b);
String d=String.copyValueOf(a,1,3);//静态方法//将字符数组转换成字符串 2是起始位4是个数
sos(d);
String f="aaaaaaaaaa";
char []dd=f.toCharArray();//字符串转换成字符数组
for(int aa=0;aa<dd.length;aa++)
{
sos(dd[aa]);
}
byte []ddd=f.getBytes();
for(int aa=0;aa<ddd.length;aa++)
{
sos(ddd[aa]);
}
}
public static void ee()//转换
{
String a="   abcdABDE    ";
String b="aba";
String c="aba";
sos(a.toUpperCase());//小写字母转换成大写
sos(a.toLowerCase());//大写字母转成小写
sos(a.trim());//对字符串的两端的多个空格去除
sos(b.compareTo(c));//对两个字符串比较 比的是ISC码


}
public static void ff()//替换
{
String a="aabbddee";
String b=a.replace('b','Q');//把字符串里面的b替换成了q
//如果被替换的字符串不存在返回的还是原串
sos(b);
}
public static void gg()
{
String a="guowei,guoyingping,guojingping,guojingping";
String []b=a.split(",");//切割字符串 这里用逗号,作为分隔符
for(int c=0;c<b.length;c++)
{
sos(b[c]);
}
}
public static void hh()//获取
{
String a="abcdefghijklnm";
String b=a.substring(2);//获取字符串中的一部分  这里是从第二个开始获取
sos(b);
String c=a.substring(3,8);//这里是从第三个开始获取 不要尾角标
sos(c);


}
public static void main(String[] args) //BOOS
{
//aa();
//bb();
//cc();
//dd();
//ee();
//ff();
//gg();
hh();
}

public static void sos(Object a)//打印封装成了函数
{
System.out.println(a);
}
}