java 正则表达式 需要转义的 java正则表达式换行符

今天学习到正则表达式，真有意思。
在jdk文档中 Patten类有具体的规则描述：
常用的是这几个：

A:字符
x 字符 x。举例：‘a’表示字符a
\ 反斜线字符。
\n 新行（换行）符 (’\u000A’)
\r 回车符 (’\u000D’)

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

C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? .
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须有这些东西组成

D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi

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

---

正则表达式的判断功能：
现在展示俩个例子，一个验证手机号码，一个验证邮箱：

package com.st.basis.day14.RegularExpression;

import java.util.Scanner;

/*
 * 正则表达式的应用
 * 规则看jdk文档  Patten类
 * */

public class RegaxDemo {

	public static void main(String[] args) {
//		判断手机号码是否符合要求
		labe:while(true){
			Scanner sc = new Scanner(System.in);
			System.out.println("输入手机号");
			String input = sc.nextLine();
			boolean out = demo01(input);
			System.out.println(out); //输出验证的结果，true/fasle
			while(out == true){
				sc.close();
//				return;       //正确就跳出循环。  
				break labe;  //俩种跳出循环方式
			}
		}
	
	
		//判断邮箱
		while(true){
			Scanner sc = new Scanner(System.in);
			System.out.println("输入邮箱号");
			String input = sc.nextLine();
			boolean out = demo02(input);
			System.out.println(out);
			while(out == true){
				sc.close();
				return;
			}
		}
	}
	
	//正则表达式判断功能
	//String类中的public boolean matches(String regax)
	private static boolean demo01(String input) {
		String regax = "1[3-7]\\d{9}";
		boolean res = input.matches(regax);
		return res;
	}
	
	//判断邮箱
	private static boolean demo02(String input) {
		/*	
		 * [e-mail]
		 * [e-mail]
		 * [e-mail]
		 * 分析： @前面的字符可能是数字也可能是字母，且数量不确定  ：  [a-zA-Z_0-9]+  
		 *    然后    @												[a-zA-Z_0-9]+@  			
		 *    @后面的也不确定是数字还是字母但肯定没大写.且数量不确定，但大致在2到6之间    [a-z_0-9]{2,6}         [a-zA-Z_0-9]+@[a-z_0-9]{2,6}
		 *    然后  加一个点    \\.									[a-zA-Z_0-9]+@[a-z_0-9]{2,6}\\.
		 *    然后后面只有英文    [a-z]								[a-zA-Z_0-9]+@[a-z_0-9]{2,6}\\.[a-z]
		 *    但  .后面可能有好几个后缀 就需要改进      (\\.[a-z]{2,3})+		[a-zA-Z_0-9]+@[a-z_0-9]{2,6}(\\.[a-z]{2,3})+
		 *    
		 * */
		
		String regax = "[a-zA-Z_0-9]+@[a-z_0-9]{2,6}(\\.[a-z]{2,3})+";
		boolean res = input.matches(regax);
		return res;
	}

}

---

正则表达式的分割功能：

package com.st.basis.day14.RegularExpression;

import java.util.Arrays;
import java.util.Scanner;

/*
 * 
 * 正则表达式的应用
 * 规则看jdk文档  Patten类
 * 分割功能
 * 
 * 应用实例：
 * 		上网站搜索，自己想限定年龄为 18-24岁女性
 *		那在搜索条件中写入这个条件，提交以后系统拿到的就是一个字符串  "18-24"
 *		系统进行比对就需要拿到18和24，而不是这个字符串
 *		就可以用正则的分割功能
 * 		public String[] split(String regex) 
 * 		注意该方法返回的是一个String[]
 * */

public class RegaxDemo2 {

	public static void main(String[] args) {
		demo01();  //搜索限定年龄
		demo02();  //分割字符串
		demo03();   //分割字符串并且排序
  	}

	private static void demo01() {   //搜索限定年龄
		//输入筛选条件
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入年龄范围：");
		String range = sc.nextLine();
		
		//定义规则
		String regax = "-";   //输入的字符串格式是   18-24  规则就是 -
		//调用
		String[] arr = range.split(regax);  //得到的是arr，里面放着 18，24
		//获取数组中的值并转为int
		int snum = Integer.parseInt(arr[0]);   //得到了18
		int endnum = Integer.parseInt(arr[1]); //得到了24
		//筛选判断
		System.out.println("请输入年龄");
		int age = sc.nextInt();
		if(age >= 18 && age <= 24){
			System.out.println("合格");
		}else{
			System.out.println("不合格");
		}
		sc.close();
	}
	
	//
	private static void demo02() {
		String str = "aa,bb,cc";   //将aa,bb,cc这个字符串按 aa   bb  cc 输出
		String[] arr = str.split(",");  //调用方法  规则就是,
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i]+"  ");
		}
		System.out.println();
		System.out.println("-----------------");
		
		String str2 = "dd.ee.ff";
		String[] arr2 = str2.split("\\.");  //调用方法    规则是.  但在正则中.代表任意字符，所以需要转义
		for(int i=0; i<arr2.length; i++){
			System.out.print(arr2[i]+"  ");
		}
		System.out.println();
		System.out.println("-----------------");
		
		String str3 = "gg   hh        qq";  //这个字符串中间有空格，但不确定有几个
		String[] arr3 = str3.split(" +");  //调用方法   空格+ 代表一次或一次以上 	
		for(int i=0; i<arr3.length; i++){
			System.out.print(arr3[i]+"  ");
		}
		System.out.println();
		System.out.println("-----------------");
		
		//硬盘中用\\代替\
		String str4 = "F:\\学习资料\\01、第一阶段 Java基础(27天)\\day26\\avi";  
		String[] arr4 = str4.split("\\\\");  //调用方法   正则中\\代表\ 	
		for(int i=0; i<arr4.length; i++){
			System.out.print(arr4[i]+"         ");
		}
		System.out.println();
		System.out.println("-----------------");
	}
	

	
	private static void demo03() {
		String str = "27 89 75 22 15";
		String[] arr = str.split(" ");
		//字符串数组转int数组
		int[] arr2 = new int[arr.length];
		for(int i=0; i<arr.length; i++){
			arr2[i] = Integer.parseInt(arr[i]);       
		}
		//现在排序
		Arrays.sort(arr2);  //二分排序
		
		//数组转字符串并输出
		String res = Arrays.toString(arr2);
		System.out.println(res);  //输出的是：[15, 22, 27, 75, 89] 但我不喜欢这个格式就自己拼接
		
		//自己拼接
		StringBuilder sb = new StringBuilder();
		for(int i=0; i<arr.length; i++){
			if(i<arr.length-1){
				sb.append(arr2[i]).append(" ");   
			}else{
				sb.append(arr2[i]);
			}
			    
		}
		System.out.println(sb.toString());
	}
}

结果：

[15, 22, 27, 75, 89]
15 22 27 75 89

---

正则表达式的替换功能：

package com.st.basis.day14.RegularExpression;

/*
 * 正则表达式
 * 替换功能
 * public String replaceAll(String regex,String replacement)
 * 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
 * */

public class RegaxDemo3 {

	public static void main(String[] args) {
		demo01();
	}

	private static void demo01() {
		String str = "hohot666beijing123java";
		//去除所有数字，用*替换
		String regax  = "\\d+";  //正则 规则
		String s  = "*";   //替换的字符串
		//调用方法
		String res = str.replaceAll(regax, s);
		System.out.println(res);
	}



}

结果

hohot*beijing*java

---

正则表达式的获取功能：

package com.st.basis.day14.RegularExpression;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 正则表达式
 * 获取功能
 * 	API说明：
 *  Pattern和Matcher类的使用
 * 	public final class Patternextends Object implements Serializable 	
 * 	正则表达式的编译表示形式。	
 * 	
 * 	指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 
 *
 *	因此，典型的调用顺序是 
 *
 *	Pattern p = Pattern.compile("a*b");
 *	Matcher m = p.matcher("aaaaab");
 *	boolean b = m.matches();
 * */

public class RegaxDemo4 {

	public static void main(String[] args) {
		demo01();   //引出
		demo02();
	}


	private static void demo01() {
		 //将这个规则编译成模式对象
		 Pattern p = Pattern.compile("a*b"); //"a*b"是一个规则      *：0次或多次
		 //通过模式对象得到匹配器对象
		 Matcher m = p.matcher("aaaaab");  //"aaaaab"是需要匹配的字符串
		 boolean b = m.matches();  //调用匹配去对象的功能
		 System.out.println(b);   //输出结果  true
		 
		 //上述是一个针对与API例子做的demo，但实际要满足上述需求这样做就可以：
		 String str = "aaaaab";
		 String regex = "a*b";
		 boolean res = str.matches(regex);
		 System.out.println(res);
	}
	
	//获取功能：获取下列字符串中由三个字符组成的单词
	//String str = "ni hao a, wo shi java ai hao zhe.ni ne ?"
	private static void demo02() {
		String str = "ni hao a, wo shi java ai hao zhe.ni ne ?";
		String regex = "\\b[a-zA-Z]{3}\\b";      // \b单词边界      [a-zA-Z]{3}三个字符组成的字串
		//将这个规则编译成模式对象
		Pattern p = Pattern.compile(regex); 
		//通过模式对象得到匹配器对象
		Matcher m = p.matcher(str);  
		//调用匹配去对象的功能
		//通过find方法	查找有没有满足条件的字串
		boolean res = m.find();
		System.out.println(res);  //输出 true 说明有符合规则的字串
		
		//下面输出这些字串
		while(m.find()){
			System.out.println(m.group());   //先利用find方法，再利用group方法
		}
		
	}

}

结果

true
shi
hao
zhe