JAVA 基础知识整理-10正则表达式Regex, Pattern类，Matcher类，Math类，System类~Calendar类

1.正则表达式

boolean matches(String regex)
通知此字符串是否匹配给定的正则表达式。
String[] split(String regex)
根据给定的正则表达式的匹配来拆分此字符串。
String replaceAll(String regex, String replacement)
使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。
告诉这个字符串是否匹配给定的 regular expression 。

构造	匹配
字符
x	字符 x
\\	反斜线字符
\0n	带有八进制值 0n 的字符(0 <= n <= 7)
\0nn	带有八进制值 0nn 的字符(0 <= n <= 7)
\0mnn	带有八进制值 0mnn 的字符(0 <= m <= 3、0 <= n <= 7）
\xhh	带有十六进制值 0xhh 的字符
\uhhhh	带有十六进制值 0x hhhh 的字符
\t	制表符 (’\u0009’)
\n	新行（换行）符 (’\u000A’)
\r	回车符 (’\u000D’)
\f	换页符 (’\u000C’)
\a	报警 (bell) 符 (’\u0007’)
\e	转义符 (’\u001B’)
\c	x 对应于 x 的控制符
字符类
[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]（减）
预定义字符类
.	任何字符（与行结束符可能匹配也可能不匹配）
\d	数字：[0-9]
\D	非数字： [^0-9]
\s	空白字符：[ \t\n\x0B\f\r]
\S	非空白字符：[^\s]
\w	单词字符：[a-zA-Z_0-9]
\W	非单词字符：[^\w]
POSIX 字符类（仅 US-ASCII）
\p{Lower}	小写字母字符：[a-z]
\p{Upper}	大写字母字符：[A-Z]
\p{ASCII}	所有 ASCII：[\x00-\x7F]
\p{Alpha}	字母字符：[\p{Lower}\p{Upper}]
\p{Digit}	十进制数字：[0-9]
\p{Alnum}	字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}	标点符号：!"#$%&’()*+,-./:;<=>?@[]^_`{
\p{Graph}	可见字符：[\p{Alnum}\p{Punct}]
\p{Print}	可打印字符：[\p{Graph}\x20]
\p{Blank}	空格或制表符：[ \t]
\p{Cntrl}	控制字符：[\x00-\x1F\x7F]
\p{XDigit}	十六进制数字：[0-9a-fA-F]
\p{Space}	空白字符：[ \t\n\x0B\f\r]
java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase}	等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase}	等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace}	等效于 java.lang.Character.isWhitespace()
\p{javaMirrored}	等效于 java.lang.Character.isMirrored()
Unicode 块和类别的类
\p{InGreek}	Greek 块（简单块）中的字符
\p{Lu}	大写字母（简单类别）
\p{Sc}	货币符号
\P{InGreek}	所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]]	所有字母，大写字母除外（减去）
边界匹配器
^	行的开头
$	行的结尾
\b	单词边界
\B	非单词边界
\A	输入的开头
\G	上一个匹配的结尾
\Z	输入的结尾，仅用于最后的结束符（如果有的话）
\z	输入的结尾
Greedy 数量词
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次
Reluctant 数量词
X??	X，一次或一次也没有
X*?	X，零次或多次
X+?	X，一次或多次
X{n}?	X，恰好 n 次
X{n,}?	X，至少 n 次
X{n,m}?	X，至少 n 次，但是不超过 m 次
Possessive 数量词
X?+	X，一次或一次也没有
X*+	X，零次或多次
X++	X，一次或多次
X{n}+	X，恰好 n 次
X{n,}+	X，至少 n 次
X{n,m}+	X，至少 n 次，但是不超过 m 次
Logical 运算符
XY	X 后跟 Y
X|Y	X 或 Y
(X)	X，作为捕获组
Back 引用
\n	任何匹配的 nth 捕获组
引用
\	Nothing，但是引用以下字符
\Q	Nothing，但是引用所有字符，直到 \E
\E	Nothing，但是结束从 \Q 开始的引用
特殊构造（非捕获）
(?:X)	X，作为非捕获组
(?idmsux-idmsux)	Nothing，但是将匹配标志由 on 转为 off
(?idmsux-idmsux:X)	X，作为带有给定标志 on - off 的非捕获组
(?=X)	X，通过零宽度的正 lookahead
(?!X)	X，通过零宽度的负 lookahead
(?<=X)	X，通过零宽度的正 lookbehind
(?<!X)	X，通过零宽度的负 lookbehind
(?>X)	X，作为独立的非捕获组

String s = "D:\\note pad file\\Python files\\2020.3";
		String[] strarray = s.split("\\\\");
		for(int i = 0;i<strarray.length ;i++){
			
				System.out.print(strarray[i]+"  ");
			
		}
输出：
D:  note pad file  Python files  2020.3  

利用正则分割字符串，并排序（冒泡排序）：

String num ="12,12,14,17,90,30,11,3,5,23,14";
		
		//1.将字符串通过正则表达式转为字符串数组
		//2.遍历字符串数组，用Integer.parseInt()转为数字，并比较
		//3.遍历排序后的数组，用StringBuilder添加元素并转成字符串
		String sorted = SortNumString(num);
		System.out.println("");
		System.out.println(sorted);
	}
	public static String SortNumString(String sa){
		  String[] numarray = sa.split(",");
		  
		  for(int x = numarray.length; x > 0; x--){
			  for(int y = 0; y < x-1; y++){
				  int m = Integer.parseInt(numarray[y]);
				  int n = Integer.parseInt(numarray[y+1]);
				  if(m>n){
					  String max = numarray[y];
					  numarray[y] = numarray[y+1];
					  numarray[y+1] = max;
				  }
			  }			  
		  }
		  StringBuilder sb =new StringBuilder();
		  for(int i = 0; i<numarray.length; i++){
			  sb.append(numarray[i]).append("  ");
		  }		
		return sb.toString();	
	}
	输出：
	3  5  11  12  12  14  14  17  23  30  90  

使用Array的排序方法

String num ="12,12,14,17,0,90,30,11,3,5,23,14";
		//1.将字符串通过正则表达式转为字符串数组
		//2.遍历字符串数组，用Integer.parseInt()转为数字，直接调用Array的排序功能
		//3.遍历整数数组，用冒泡排序的方式排列数组，并将数组转为字符串
		String sorted = SortNumString(num);
		System.out.println("");
		System.out.println(sorted);
	}
	public static String SortNumString(String sa){
		  String[] numarray = sa.split(",");
		  int[] intarray = new int[numarray.length];
		  StringBuilder sb =new StringBuilder();		  
		 for(int i = 0; i<numarray.length; i++){
			 intarray[i] = Integer.parseInt(numarray[i]);
		 }
		 Arrays.sort(intarray);
		 for(int j = 0; j<intarray.length;j++){
			 sb.append(intarray[j]).append(" ");
		 }
		 return sb.toString();
	}
输出：0 3 5 11 12 12 14 14 17 23 30 90 

正则替换功能：

	String s = "3,3,4,4,5";
	String news = s.replaceAll(",", "*");
	System.out.println(news);
	输出：3*3*4*4*5

2.Pattern 类 和Matchers类

Pattern 正则表达式的编译表示形式。
Matcher 通过解释 Pattern 对 字符序列 执行匹配操作的引擎。

使用：
Pattern p = Pattern.compile(“a*b”);
Matcher m = p.matcher(“aaaaab”);
boolean b = m.matches();

	 String s = "3,3,4,4,5";
	 Pattern p =Pattern.compile("\\d+");
	 Matcher m = p.matcher(s);
	 boolean b = m.matches();
	 System.out.println(b);
	 while( m.find()){
		System.out.println(m.group());
	}

boolean b = Pattern.matches("a*b", "aaaaab");

2. Math类的概述以及成员方法

Math 类包含执行初等指数、对数、平方根及三角函数等这些基本数值操作所用的方法。

主要方法

public static int abs(int a)
返回 int 值的绝对值。
public static double ceil(double a)
返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个整数。
public static double floor(double a)
返回最大的（最接近正无穷大）double 值，该值小于或等于参数，并且等于某个整数。
static int max(int a, int b)
返回两个 int 值中较大的一个。
static int min(int a, int b)
返回两个 int 值中较小的一个。
static double pow(double a, double b)
返回第一个参数的第二个参数次幂的值。
static double random()
返回带正号的 double 值，大于或等于 0.0，小于 1.0。
static int round(float a)
返回最接近参数的 int。
static double sqrt(double a)
返回正确舍入的 double 值的正平方根。

public class MathDemo {
	public static void main(String[] args) {
		System.out.println(Math.abs(-5));
		System.out.println(Math.ceil(-5.888));
		System.out.println(Math.floor(-5.888));
		System.out.println(Math.min(87,99));
		System.out.println(Math.max(87,99));
		System.out.println(Math.max(Math.max(87,99), 100));
		System.out.println("==================================");
		//生成300到400之间的随机整数
		getRandom(300,400);
	}
	public static void getRandom(int min, int max){
		for(int i = 0; i < 100; i++){
			System.out.print((int)(Math.random()*(max-min+1))+min+"   ");
		}
	}
}
输出：
5
-5.0
-6.0
87
99
100
==================================
390   312   380   330   329   333   335   334   377   364   335   325   387   357  334   377   364   335   325   387   357   373   397   340   348   376   338   397   301   329   333   319   393   354   312   346   340   326   378   316   384   382   315   340   400   345   398   373   378   372   397   343   308   351   349   321   381   348   386   387   352   324   351   302   350   387   381   390   331   307   315   398   366   327   328   399   335   370   375   省略复制。。。。。

3. System 类

System 类包含一些有用的类字段和方法。它不能被实例化。
在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

static java.io.PrintStream err
“标准”错误输出流。
static java.io.InputStream in
“标准”输入流。
static java.io.PrintStream out
“标准”输出流。

主要方法：

static void gc()
运行垃圾回收器。
调用 System.gc() 实际上等效于调用：Runtime.getRuntime().gc()

static void exit(int status)
终止当前正在运行的 Java 虚拟机。
static long currentTimeMillis()
返回以毫秒为单位的当前时间。
返回当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

public class SystemDemo {
	public static void main(String[] args) {
		System.out.println(System.currentTimeMillis());
		int[] i = {1,2,2,4,5,2,9};
		int[] newi = new int[i.length];
		System.arraycopy(i, 0, newi, 0, i.length);
		for(int x: newi){
			System.out.println(x);
		}
		
	}
}

输出：
1583285821500
1 2 2 4 5 2 9 

4. BigInteger类
不可变的任意精度整数。如果超过Integer所能表示的数值范围，那么就要用BigInteger。

常用构造方法：
BigInteger(String val)
将BigInteger的十进制字符串表示形式转换为BigInteger。
将指定字符串转为BigInteger值
BigInteger(String val, int radix)
传入指定进制的数字字符串，返回其十进制的BigInteger

	BigInteger b = new BigInteger("100000000");
	BigInteger bi = new BigInteger("100000000",2);
	System.out.println(b);
	System.out.println(bi);
	输出：
	100000000
	256

常用方法：
（加减乘除）
BigInteger add(BigInteger val)
返回值为 (this + val) 。
BigInteger subtract(BigInteger val)
返回值为 (this - val) 。
BigInteger multiply(BigInteger val)
返回值为 (this * val) 。
BigInteger divide(BigInteger val)
返回值为 (this / val) 。
BigInteger remainder(BigInteger val)
返回值为 (this % val) 。
String toString()
返回此BigInteger的十进制字符串表示形式。

	BigInteger b = new BigInteger("100000000");
	BigInteger c = new BigInteger("500000");
	System.out.println(b.subtract(c));
	System.out.println(b.add(c));
	System.out.println(b.multiply(c));
	System.out.println(b.divide(c));
	System.out.println(b.remainder(c));
	输出：
	99500000
	100500000
	50000000000000
	200
	0

5. BigDecimal类
不变的，任意精度的带符号的十进制数字。 A BigDecimal由任意精度整数未缩放值和32位整数级别组成 。 如果为零或正数，则刻度是小数点右侧的位数。 如果是负数，则数字的非标定值乘以10，以达到等级的否定的幂。 因此，BigDecimal所代表的BigDecimal值为(unscaledValue × 10-scale) 。
注：为了避免累积损失，金融业等要求比较高的行业要使用BigDecimal

常用构造方法：
BigDecimal(BigInteger val)
将 BigInteger转换成 BigDecimal

常用方法：

BigDecimal add(BigDecimal augend)
返回 BigDecimal ，其值是 (this + augend) ，其标为 max(this.scale(), augend.scale()) 。

BigDecimal subtract(BigDecimal subtrahend)
返回 BigDecimal ，其值是 (this - subtrahend) ，其标为 max(this.scale(), subtrahend.scale()) 。

BigDecimal multiply(BigDecimal multiplicand)
返回 BigDecimal ，其值是 (this × multiplicand)，其标为 (this.scale() + multiplicand.scale()) 。

BigDecimal divide(BigDecimal divisor)
返回BigDecimal ，其值为(this / divisor) ，优先级为(this.scale() - divisor.scale()) ; 如果不能表示确切的商（因为它具有非终止的十进制扩展），则抛出一个ArithmeticException 。

String toString()
返回此 BigDecimal的字符串表示，如果需要指数，则使用科学计数法。

	System.out.println(0.09+0.01);
	BigDecimal bd = new BigDecimal("0.09");
	BigDecimal bd0 = new BigDecimal("0.01");
	System.out.println(bd.add(bd0));
	输出：
	0.09999999999999999
	0.10

6. Date类

用于表示日期的类，大部分方法已经过时，少部分还在使用。

构造方法：
Date()
分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。

Date(long date)
分配一个 Date对象，并将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数，即1970年1月1日00:00:00 GMT。

常用方法：
long getTime()
返回自1970年1月1日以来，由此 Date对象表示的00:00:00 GMT的毫秒 数 。

void setTime(long time)
设置此 Date对象以表示1970年1月1日00:00:00 GMT后的 time毫秒的时间点。

	System.out.println(new Date());
	Date d = new Date();
	System.out.println(d);
	d.setTime(1000*60);
	System.out.println(d);
	System.out.println(d.getTime());
	输出：
	Wed Mar 04 21:51:28 CST 2020
	Wed Mar 04 21:51:28 CST 2020
	Thu Jan 01 08:01:00 CST 1970
	60000

7. DateFormat类
DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间。 日期/时间格式化子类（如SimpleDateFormat ）允许格式化（即日期文本），解析（文本日期）和归一化。 该日期表示为一个Date对象，或自1970年1月1日00:00:00 GMT以来的毫秒。

因为DateFormat是一个抽象类，所以使用具体子类SimpleDateFormat。

构造方法：
protected DateFormat()
创建一个新的日期格式。

常用方法：

String format(Date date)
将日期格式化成日期/时间字符串。

Date parse(String source)
从给定字符串的开始解析文本以生成日期。

8.SimpleDateFormat类
SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。 它允许格式化（日期文本），解析（文本日期）和归一化。

构造方法：
SimpleDateFormat()
构造一个 SimpleDateFormat使用默认模式和日期格式符号为默认的 FORMAT区域设置。

SimpleDateFormat(String pattern)
使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。

SimpleDateFormat(String pattern, DateFormatSymbols formatSymbols)
使用给定的模式和日期格式符号构造一个 SimpleDateFormat 。

SimpleDateFormat(String pattern, Locale locale)
构造一个 SimpleDateFormat使用给定的模式和给定的区域设置的默认日期格式符号。

Date===>String:

	Date d = new Date();
	SimpleDateFormat adf = new SimpleDateFormat();
	System.out.println(adf.format(d));//默认模式
	SimpleDateFormat adf0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//给定模式
	System.out.println(adf0.format(d));
	输出：
	20-3-4 下午10:43
	2020-03-04 22:43:06

注：format方法是父类DateFormat类的方法
public final String format(Date date)

String===>Date:

	String s = "2020-03-04 22:43:06";
	SimpleDateFormat adf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	try {
		Date dd= adf1.parse(s);
		System.out.println(dd);
	} catch (ParseException e) {
		e.printStackTrace();
	}
	
输出：
Wed Mar 04 22:43:06 CST 2020

DateString 工具类：

Date d = new Date();
	String form = "yyyy年MM月dd日";	
	String date = dateToString(d,form);
	System.out.println(date);
	System.out.println("=================================");
	String newdate = "2018年3月5日7时37分";
	String form1 = "yyyy年MM月dd日HH时mm分";
	Date parseddate = stringToDate(newdate,form1);
	System.out.println(parseddate);
}
public static String dateToString(Date date,String form){
	return new SimpleDateFormat(form).format(date);
}
public static Date stringToDate(String newdate,String form) throws ParseException{
	return new SimpleDateFormat(form).parse(newdate);
}

存在天数案例：

public class YourDaysDemo {
public static void main(String[] args) throws ParseException {
	String birth = "1985年9月5日";
	long nowmiliseconds = System.currentTimeMillis();
	Date d = new SimpleDateFormat("yyyy年MM月dd日").parse(birth);
	long mymillissencond =d.getTime();
	long existingmillis = nowmiliseconds-mymillissencond;
	long mydays = existingmillis/1000/60/60/24;
	System.out.println(mydays);
}
}
输出：
12600

9. Calender类

是一个抽象类，它为特定瞬间与一组诸如YEAR,MONTH,DAY_OF_MONTH,HOUR等字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

常用方法：

public static Calender getinstance()
使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间，使用了默认时区和默认语言环境。
public int get(int field)
返回给日历字段的值，日历类中的每个日历字段都是静态的成员变量，且是int类型
public void add(int filed, int amount)
根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public final void set(int year,int month,int date)
设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。

import java.util.Calendar;

public class CalenderDemo {
public static void main(String[] args) {
	
	Calendar now =Calendar.getInstance();
	int year = now.get(Calendar.YEAR);
	int month = now.get(Calendar.MONTH);
	int date = now.get(Calendar.DATE);
	
	System.out.println(year+"-"+(month+1)+"-"+date);//月份是0~11
	now.add(Calendar.YEAR, 5);
	System.out.println(now.get(Calendar.YEAR));
	now.set(2030, 9, 12);
	System.out.println(now.get(Calendar.YEAR)+"-"+(now.get(Calendar.MONTH)+1)+"-"+now.get(Calendar.DATE));
}
}
输出：
2020-3-5
2025
2030-10-12

用Calendar类计算天数

Calendar c1= Calendar.getInstance();
Calendar c = Calendar.getInstance();
	c.set(1985, 8, 5);//这里因为月份是0~11，因此传入n,实际代表的是n+1月，因此要减1
	long mydays = (System.currentTimeMillis()-c.getTimeInMillis())/1000/60/60/24;
	long mydays1 = (c1.getTimeInMillis()-c.getTimeInMillis())/1000/60/60/24;
	System.out.println(mydays);
	System.out.println(mydays1);
输出：
12600
12600

获取任意年份二月的天数：

import java.util.Calendar;

public class FebDaysDemo {
	public static void main(String[] args) {
		int year = 2020;
		Calendar c = Calendar.getInstance();
		c.set(year, 2,1);
		c.add(Calendar.DATE, -1);
		System.out.println(c.get(Calendar.DATE));
	}
}
输出：
29