Java的正则表达式的使用

校验qq号
 * 要求必须是5--15位数字，不能是10开头，必须是数字
 * a：非正则表达式实现

 * b：正则表达式实现

package com.heima.zhengze;

public class Demo1 {
/*
 *A：正则表达式：
 *		是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串，其实就是一种规则，有自己特殊的运用、
 *		作用：比如注册邮箱，邮箱有用户名和密码，一般对其限制长度，这个限制长度的事情就是正则表达式的作用
 *
 *B：案例： 	
 *		校验qq号
 *			要求必须是5--15位数字，不能是10开头，必须是数字
 *			a：非正则表达式实现
 *			b：正则表达式实现
 * */
	public static void main(String[] args) {
//		System.out.println(chackQQ("013545"));//不能以0开头所以是false
//		System.out.println(chackQQ("5646846"));//true
		//这样写太痛苦
		
		String regex="[1-9]\\d[4,14]";
		System.out.println("2553868".matches(regex));
	}
/*
 * 明确返回值类型，Boolean
 * 明确参数列表String qq
 * */
		public static boolean chackQQ(String qq){
			boolean flag=true;		//如果校验不符合要求把flag改为false
			if(qq.length()<16&&qq.length()>4){
				if(!qq.startsWith("0")){
					char[] arr=qq.toCharArray();
					for(int i=0;i<arr.length;i++){
						char ch=arr[i];
						if(ch>=0&&ch<=9){
					}else{
						 return flag=false;
					}
					}
				}else{
					return flag=false;
				}
		}else{
			return flag=false;
		}
			return flag;
}
	
		}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

字符类

package com.heima.zhengze;

public class Demo2_Regex {
/*
 * 字符类 
		[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]（减去） 

 * */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		
		
	}

private static void demo4() {
	String regex="[a-d[m-p]]";// a 到 d 或 m 到 p：[a-dm-p]（并集） 
	System.out.println("a".matches(regex));
}

	private static void demo3() {
		String regex="[a-zA-z]";//a 到 z 或 A 到 Z，两头的字母包括在内（范围） 
		System.out.println("f".matches(regex));
		System.out.println("Z".matches(regex));
	}

private static void demo2() {
	String regex="[^abc]";	//[^abc] 任何字符，除了 a、b 或 c（否定） 
	System.out.println("a".matches(regex));	//false
	System.out.println("fiaji".matches(regex));//false
	System.out.println("j".matches(regex));//true
}

private static void demo1() {
	String regex="[abc]";		//[]代表单个字符
	System.out.println("a".matches(regex));		//true
	System.out.println("abc".matches(regex));	//false
}

}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

预定义字符类、

package com.heima.zhengze;

public class Demo3_regex {
/*
 * 预定义字符类 
		. 任何字符（与行结束符可能匹配也可能不匹配） 
		\d 数字：[0-9] 
		\D 非数字： [^0-9] 
		\s 空白字符：[ \t\n\x0B\f\r] 
		\S 非空白字符：[^\s] 
		\w 单词字符：[a-zA-Z_0-9] 
		\W 非单词字符：[^\w] 

 * */
	public static void main(String[] args) {
//		德莫();
//		demo2();
//		demo3();
//		demo4();
//		demo5();
		String regex="\\w";//单词字符，字母，下划线，数字
		System.out.println("2".matches(regex));//true
		System.out.println("_".matches(regex));//true
	}

private static void demo5() {
	String  regex ="\\S";
	System.out.println("ss".matches(regex));//false
	System.out.println(" ".matches(regex));//false
	System.out.println("a".matches(regex));//true
}

private static void demo4() {
	String regex="\\s";  //代表空白字符
	System.out.println(" ".matches(regex));//true
	System.out.println("".matches(regex));//false
	System.out.println("   ".matches(regex));//fasle
}

private static void demo3() {
	String regex="\\D";//除了0--9
	System.out.println("a".matches(regex));//true
}

private static void demo2() {
	String regex="\\d";//因为反斜线是转义字符，如果想代表预定义字符类需要\\d
	System.out.println("0".matches(regex));//true
	System.out.println("a".matches(regex));//false
}

private static void 德莫() {
	String regex=".";
	System.out.println("a".matches(regex));//true
	System.out.println("ad".matches(regex));//false,因为只能一个点只能代表一个任意字符，如果想代表两个任意字符，需要两个点
}

}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

数量词

package com.heima.zhengze;

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

 * */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo();
		//demo4();
	}

public static void demo4() {
	String re="[abc]{5}";//单个字符恰好出现五次
	System.out.println("aaaaa".matches(re));//true
}

private static void demo() {
	String  regex="[abc]+";//单个字符出现一次或多次
	System.out.println("".matches(regex));//没有出现false
	System.out.println("a".matches(regex));//true
}

private static void demo2() {
	String regex="[abc]*";//abc出现0次或者多次
	System.out.println("abc".matches(regex));//true
	System.out.println("".matches(regex));//true
}

private static void demo1() {
	String regex="[abc]?";//单个字符出现一次或者一次也没有
	System.out.println("a".matches(regex));
	System.out.println("".matches(regex));//true，这个叫一次也没有
	System.out.println("d".matches(regex));//fasle,这不叫一次也没有
}

}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

正则表达式的分割功能

package com.heima.zhengze;

public class Demo5_Split {

	public static void main(String[] args) {
		String s="金三胖 郭美美 李dayone";
		String[] arr=s.split(" ");//用空格切割
		
		for (int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
		
		String s2="金三胖.郭美美.李dayone";
		String[] arr2=s2.split("\\.");   //用点切割,通过正则表达式切割字符串
		
		for (int i2=0;i2<arr2.length;i2++){
			System.out.println(arr2[i2]);
		}
	}
	
}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

练习：把给定字符串中的数字排序

package com.heima.Test;

import java.lang.reflect.Array;
import java.util.Arrays;

public class Test1 {
/*
 * 我有字符串“91 27  46  28  50”，让其排序
		 * 1.将字符串切割成字符串数组
		 * 2.将字符串转换成数字，并将其存储在一个等长度的int数组中
		 * 3.排序
		 * 4.将排序后的数组遍历并拼接成一个字符串
 * */
	public static void main(String[] args) {
		String s="91 27 46 28 50";
		String[] arr=s.split(" ");
		int[] arr2=new int[arr.length];
		for(int i=0;i<arr.length;i++){
			arr2[i]=Integer.parseInt(arr[i]);		
	}
//		for(int i=0;i<arr2.length;i++){
//			System.out.println(arr2[i]);
//		}
		Arrays.sort(arr2);
		
//		String str="";                        用String类做可以但是不好，因为会产生很多垃圾
//		for(int i=0;i<arr2.length;i++){
//			if(i==arr2.length){
//				str+=arr[i];
//			}else{
//				str+=arr2[i]+" ";
//			}
//		}
//		System.out.println(str);
		
		StringBuffer str=new StringBuffer();
		for(int i=0;i<arr2.length;i++){
			if(i==arr2.length){
				str.append(arr2[i]);
			}else{
				str.append(arr2[i]);
				str.append(" ");
			}
		}
		System.out.println(str);
}
}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

正则表达式的替换功能

package com.heima.zhengze;

public class Demo6_RepalceAll {
/*
 * 	正则表达式的替换功能：	
 * 		String类功能：public string repalceAll(String regex,String repalcement)
 * */
	public static void main(String[] args) {
		String s="wo555dd1ai2heima";
		String regex="\\d";		
		String s2=s.replaceAll(regex, "");//把所有的数字用空串替换
		System.out.println(s2);
	}

}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

正则表达式的分组功能

package com.heima.zhengze;

public class Demo7_Regex {
/*
 * 正则表达式分组功能
 * 		捕获组可以通过从左到右计算其开括号来编号，在表达式（（A）（B（C）））中，存在以下四组、
 *			（（A）（B（C）））
 *			（A）
 *			（B（C））、
 *			（C）
 *案例演示：
 *		a：切割
 *			需求：按照叠词切割：“sdqqfgkkkhjppppkl”
 *		b：替换	
 *			需求：我我....我...我.要....要要....要学......学学学....编程
 *			将字符串还原成：我要学编程
 * */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		String s="我我....我...我.要....要要....要学......学学学....编程";
		String regex="\\.+";
		String regex2="(.)\\1+";
		String s2=s.replaceAll(regex, "");
		s2=s2.replaceAll(regex2, "$1");		//重要：加上$1代表获取第一组的字符，来替换
		System.out.println(s2);
	}

public static void demo2() {
	//需求：按照叠词切割：“sdqqfgkkkhjppppkl”
	String regex="(.)\\1+";//表示出现一次或者多次
	String s="sdqqfgkkkhjppppkl";
	String[] arr=s.split(regex);
	for(int i=0;i<arr.length;i++){
		System.out.println(arr[i]);
	}
}

	public static void demo1() {
		//叠词：快快乐乐，高高兴兴
		String regex="(.)\\1(.)\\2";//(.)\\1 就是代表第一组又出现一次  (.)\\2代表第二组又出现一次
		System.out.println("kkll".matches(regex));//返回true
		
		String regex2="(..)\\1";	//将前两个字定为一组，出现一次
		System.out.println("死啦死啦".matches(regex2));//
	}

}