一.正则表达式-特点
正则表达式:复合一定规则的表达式
作用:用于专门操作字符串。
import java.util.*;
import java.io.*;
class RegexDemo
{
public static void main(String[] args)
{
//checkQQ(); //普通方法做的
checkQQ_Regex(); //正则表达式
}
//用普通方法做的
public static void checkQQ()
{
String qq ="1231a234";
int len = qq.length();
if(len>=5&&len<=15)
{
if(!qq.startsWith("0"))
{
try
{
//Integer.parseInt(“12a”)这么写NumberFormatException(这个异常是如果输入的字符不是整数就会报出),
//但是这里5-15位,所以用long
long l = Long.parseLong(qq);
System.out.println("qq:"+l);
}
catch (NumberFormatException e)
{
System.out.println("出现非法字符");
}
}
}
else
{
System.out.println("请输入正确QQ");
}
}
//用正则表达式
public static void checkQQ_Regex()
{
String qq = "12a3123";
String reg = "[1-9][0-9]{4,14}";
boolean flag = qq.matches(reg);
if(flag)
{
System.out.println(qq+"....is ok");
}
else
{
System.out.println(qq+"...不合法");
}
}
}
二.正则表达式-匹配
正则表达式:复合一定规则的表达式。
作用:用于专门操作的字符串。
特点:用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正则表达式,就是在学习一些特殊符号的使用。
好处:可以简化对字符串的复杂操作。
作用:用于专门操作的字符串。
特点:用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正则表达式,就是在学习一些特殊符号的使用。
好处:可以简化对字符串的复杂操作。
具体操作功能:
1.匹配:String matchs方法。 用规则匹配整个字符串,只要有一处不符合规则,就匹配结束,返回false.
注意:
\d 是一个整体 所以使用时要使用双\,第一个\把第二个\转化为普通\,因为\在程序里是转义符号
\d 是一个整体 所以使用时要使用双\,第一个\把第二个\转化为普通\,因为\在程序里是转义符号
三.正则表达式-切割
正则表达式:复合一定规则的表达式。
作用:用于专门操作的字符串。
特点:用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正则表达式,就是在学习一些特殊符号的使用。
好处:可以简化对字符串的复杂操作。
弊端:符号定义越多,正则越长,阅读性越差。
2.切割:String 类中split
作用:用于专门操作的字符串。
特点:用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正则表达式,就是在学习一些特殊符号的使用。
好处:可以简化对字符串的复杂操作。
弊端:符号定义越多,正则越长,阅读性越差。
具体操作功能:
1.匹配:String ;类中 matchs方法。用规则匹配整个字符串,只要有一处不符合规则,就匹配结束,返回false.2.切割:String 类中split
import java.util.*;
import java.io.*;
class RegexDemo
{
public static void main(String[] args)
{
<span style="white-space:pre"> </span>// 按照叠词完成切割。//两个相同字母切一次,写了个+号就是出现至少一次
<span style="white-space:pre"> </span>//+代表出现至少一次
<span style="white-space:pre"> </span>//(.)\\1代表是否与第一个字完全相同,也就是后一位跟前一位的结果是一样的
<span style="white-space:pre"> </span>//可以将\规则封装成一个组。用()完成,组的出现都有编号。
<span style="white-space:pre"> </span>/从1开始。想要使用已有的组可以通过 \n(n就是组的编号)的形式获取。
splitDemo_Regex_2("eeeeeffwwgwcasfffffffff","(.)\\1+");
}
//用String方法做的
public static void splitDemo()
{
String str = "daxiong ni hao";
String reg =" ";//用空格符号切
String[] arr = str.split(reg);
System.out.println(arr[0]);
System.out.println(arr.length);//打印切了几个空格,因为遇见空格就切一次,切了9个,就说明有9个空格
for(String s :arr)
{
System.out.println(s);//图1
}
}
//用正则方式去做
public static void splitDemo_Regex()
{
String str = "woshi daxiong ni hao";
String reg = " +";//代表至少一个空格
String[] arr = str.split(reg);
System.out.println(arr.length);
for(String s:arr)
{
System.out.println(s);//图二
}
}
//需求:分成c: abc a.txt
public static void splitDemo_Regex_1()
{
String str = "c:\\abc\\a.txt";
String reg = "\\\\";
String[] arr = str.split(reg);
System.out.println(arr.length);
for(String s:arr)
{
System.out.println(s);//图片3
}
}
//改成传参数的,这样方便
public static void splitDemo_Regex_2(String s ,String regex)
{
String[] arr = s.split(regex);
System.out.println(arr.length);
for(String s1 : arr)
{
System.out.println(s1); //图四 ,把叠词全部删掉了
}
}
}
图(1)
图(2)
图(3)
图(4)
四.正则表达式-替换
具体操作功能:
1.匹配:String ;类中 matchs方法。用规则匹配整个字符串,只要有一处不符合规则,就匹配结束,返回false.
2.切割:String 类中split
3.替换:String replaceAll();
class RegexDemo
{
//一串字符中的数字用#替换
public static void main(String[] args)
{
//1
//String str = "weasd12345qwe4aewae555";
//replaceAllDemo(str,"\\d{2,}","#");//\\d{2,} 代表连续超过2个或2个
//打印出weasd#qwe4aewae#
//2
//String str1 = "erkktyqqqqwwwwzz";//将叠词替换成&
//replaceAllDemo(str1,"(.)\\1+","&");
//打印er&ty&&&
//3
//String str1 = "erkkktyqqqqwwwwzz";
//replaceAllDemo(str1,"(.)\\1+","$1"); //将重叠的字母替换成1单个字母
//$用来获取前面那个规则的组,$1代表那前面规则的第一个(1)组,多个叠词就变成一个了
//打印erktyqwz
}
public static void replaceAllDemo(String str ,String reg ,String newStr)
{
str = str.replaceAll(reg,newStr);
System.out.println(str);
}
}
五.正则表达式-获取
.获取:将字符串的符合规则的子串取出。
操作步骤:
1.将正则表达式封装成对象。(Pattern p = Pattern.compile(reg);)// compile(reg)将给定的正则表达式编译到模式中。
2.让正则对象和要操作的字符串相关联。(Matcher m = p.matcher(str);) /matcher()创建匹配给定输入与此模式的匹配器
3.关联后,获取正则匹配引擎(m.find())//尝试查找与该模式匹配的输入序列的下一个子序列。
4.通过引擎对符合规则的字串进行操作,比如取出(m.group())//返回由以前匹配操作所匹配的输入子序列。
import java.util.*;
import java.util.regex.*;
class RegexDemo
{
public static void main(String[] args)
{
getDemo_2();
}
//方法1
public static void getDemo()
{
String str = "asdasdasdasdasdq11111111223455677";
String reg = "[1-9]\\d{4,14}";
//将规则封装成对象
Pattern p = Pattern.compile(reg);
//让正则对象和要作用的字符串相关联。获取匹配器对象
Matcher m = p.matcher(str);
//当且仅当整个区域序列匹配此匹配器的模式时才返回 true。
System.out.println(m.matches());//打印false
}
public static void getDemo_2()
{
String str = "ming tian jiu yao fang jiu yao fang jia le da jia";
String reg = "\\b[a-z]{4}\\b";//找四个字母的单词,\b单词边界,否则会取到ming中的min
//将规则封装成对象
Pattern p = Pattern.compile(reg);
//让正则对象和要作用字符串相关联
Matcher m = p.matcher(str); //matcher(CharSequence input) 创建匹配给定输入与此模式的匹配器。
//先按照reg的规则匹配一次,匹配好了,就按下面的打印
//boolean b = m.find();//将规则作用到字符串上,并进行复核规则的字符串查找
//System.out.println(b);
//System.out.println("matcher:"+m.matches());//会打印false,因为是整体匹配,匹配ming之后str后面还有,
//所以就返回false,但因为使用同一个匹配器,所以后面的group是从tian开始索引
while(m.find())
{
System.out.println(m.group());//用于获取匹配后结果,如果没有匹配就打印会报错
System.out.println(m.start()+"-----"+m.end());//可以获取开头结尾的位置
//ming
//0-----4
//tian
//5-----9
//fang
//18-----22
//fang
//31-----35
}
}
}
六.正则表达式练习
需求:将下列字符串转成:我要学编程。
到底用四种功能中的哪一个呢?或者哪几个呢?思路方式:
1.如果只想知道该字符是否对是错,使用匹配
2.想要将已有的字符串变成另一个字符串,替换
3.想要按照自定的方式将字符串变成多个字符串。切割。获取规则以外的子串。
4.想要拿到复合需求的字符串子串,获取。获取复合规则的子串。
import java.util.regex.*;
class RegexDemo
{
public static void main(String[] args)
{
String str = "我我...我...我要...要要...要要...学学...学学....编编编.....编程..程";
String str1 = str.replaceAll("\\.","");
System.out.println(str1);//我我我我要要要要要学学学学编编编编程程
String str2 = str1.replaceAll("(.)\\1+","$1");
System.out.println(str2);//我要学编程
}
}
七.正则表达式-练习2
需求(1)将ip地址进行地址段顺序的排序。
192.68.1.254.102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30
将ip地址进行地址段顺序的排序。
还按照字符串自然顺序,只要让他们每一段都是3位即可。
1.按照每一段需要的最多的0进行补齐,那么每一段就会至少保证有3位。
2.将每一段只保留3位。这样,所有的ip地址都是每一段3位。
将ip地址进行地址段顺序的排序。
还按照字符串自然顺序,只要让他们每一段都是3位即可。
1.按照每一段需要的最多的0进行补齐,那么每一段就会至少保证有3位。
2.将每一段只保留3位。这样,所有的ip地址都是每一段3位。
import java.util.*;
class RegexDemo
{
public static void main(String[] args)
{
String str = "192.68.1.254.102.49.23.013 10.10.10.10 2.2.2.2 8.109.90.30";
String str1 = str.replaceAll("(\\d+)","00$1");
// System.out.println(str1);打印00192.0068.001.00254.00102.0049.0023.00013
//去掉多余的0
str1 = str1.replaceAll("0*(\\d{3})","$1");//红色的代表0没有或多次,蓝色的代表数字出现三次,也就是说去后面三个数,前面没有0或者0出现多次
// System.out.println(str1);//打印192.068.001.254.102.049.023.013 010.010.010.010
//去掉空格
String[] arr = str1.split(" +");
TreeSet<String> ts = new TreeSet<String>();
for(String s:arr)
{
ts.add(s);
}
for(String s:ts)
{
//System.out.println(s);
//002.002.002.002
//008.109.090.030
//010.010.010.010
//192.068.001.254.102.049.023.013
System.out.println(s.replaceAll("0*(\\d+)","$1"));//去掉不要的0,去掉不要的0,(“0*(\\d{3})”,”$1”)这个是取3个0
//2.2.2.2
//8.109.90.30
//10.10.10.10
//192.68.1.254.102.49.23.13
}
}
}
需求(2)对邮件进行校验 必须掌握!!!!!
class RegexDemo
{
public static void main(String[] args)
{
checkMail();
}
public static void checkMail()
{
String mail = "abc12@sina.com";
//mail = “1@1.1”;
String reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配 //写+是一次或多次
//reg = “\\w+@\\w+(\\.\\w+)+”;//相对不太精确的匹配。
//mail.indexof(“@”)!= -1;//更不精确的匹配
System.out.println(mail.matches(reg));
}
}
八.正则表达式-网页爬虫
import java.io.*;
import java.net.*;
import java.util.regex.*;
class RegexDemo
{
public static void main(String[] args)throws Exception
{
getMails();
}
public static void getMails() throws Exception
{
URL url = new URL("http://192.168.126.1:8080//myweb/mail.html");
URLConnection conn =url.openConnection();//获取连接器
BufferedReader bufin = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line = null;
String main_reg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
//把规则封装成对象
Pattern p = Pattern.compile(main_reg);
while((line = bufin.readLine()) != null )
{
//把规则对象与要作用的字符联系起来
Matcher m = p.matcher(line);
while(m.find())
{
System.out.println(m.group());
}
}
}
}