正则表达式，Math类，System类，日期日历对象

今天内容：正则表达式，Math类，System类，日期日历对象

---

正则表达式

字符类
[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]

边界匹配器
^ 行的开头
$ 行的结尾
\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 次

//正则表达式
public class Demo2 {
	public static void main(String[] args) {
//		String s = "abc++qaawae+++jk11111111424532bcd+++++++++abccdsasdfjetw4543232";
		String s = "abc##qwe###jk111111232222bcd####abcccc3440123324";
		
/*不知道具体匹配那个字符所以我们用"."来表示任意字符，只要这个字符重复了就以他来作为切割标准，
()代表组，正则中只要使用小括号就代表一个组，组号是从1开始的，每增加一个组，组号自动+1，
后面的\\1即表示匹配第一个组，+代表至少出现一次。((A)(B(C)))共计有4个组，
第一组：((A)(B(C)))，第二组：(A)，第三组：(B(C))，第四组：(C)*/
		String regex = "(#)(.)\\1+";//???
//		String regex="\\++";//匹配字符"+"要用两个\\，后面的+表示次数≥1
		String[] str=s.split(regex);
		for (int i = 0; i < str.length; i++) {
			System.out.println(str[i]);
		}
	}
}

public class Demo3 {
	public static void main(String[] args) {
		method2();
//		method4();
//		method3();
	}

	//手机号中间四位写成*
	public static void method2(){
		String tel="13612345678";
		String regex="(1[34578][0-9])(\\d{4})(\\d{4})";
		String s=tel.replaceAll(regex, "$1****$3");//如果不在本正则表达式正引用正则表达式的组，需要使用$组号。
		System.out.println(s);
	}
	//去掉所有重复的.和重复的字
	public static void method3() {
		String s = "我我我我我我.........要要要要要要.........学学学学学学学.........Java.......编编编编...程";
		String a = s.replaceAll("\\.+", "");
		System.out.println(a);
		String b = a.replaceAll("(.)\\1+", "$1");
		System.out.println(b);
	}
	public static void method4(){
		String s="ssjddklffffjsklddddjfkkkkklsdjf111111ksd";
		String regex="(.)\\1+";
		String a=s.replaceAll(regex, "$1");
		System.out.println(a);
	}
}

正则表达式(\w)((?=\1\1\1)(\1))+到底怎么理解…

例如有字符串aaaaab，匹配过程是：
①指针从第1个字符开始匹配，\w匹配到字符a，捕获组1的内容是a，指针移动到第2个字符位置
②(?=\1\1\1)检查第2个字符开始是否紧跟着三个a，发现成立，但不匹配这三个字符，指针仍然停留在第2个字符位置
③(\1)检查第2个字符是否是a，发现成立，匹配这个字符，指针移动到第3个字符位置
重复②和③，直到其中一者不能匹配为止。返回之前已匹配到的所有字符。最终的匹配结果就是aaa。

Pattern类和Matcher类

java中Pattern这个类表示正则表达式这类事物。Pattern类没有对外提供公开的构造方法，因此我们不能创建对象。可以使用类名.方法名() 调用它里面的方法。

String regex="1[34567]\\d{9}";
Pattern pattern = Pattern.compile(regex);//静态方法，直接调用

得到正则对象之后，需要使用其中的matcher方法将正则对象和字符串关联（组合），就会得到一个匹配器对象Matcher。我们获取，切割，替换字符串中的数据时，就需要通过Matcher对象来完成。

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

//Pattern和Matcher类，从一个字符串中提取指定的内容，并输出
public class Demo4 {
	public static void main(String[] args) {
		String regex="(.)\\1+";//书写正则表达式
		Pattern pattern=Pattern.compile(regex);//将正则表达式转换成正则对象
		String s="ssjddklffffjsklddddjfkkkkklsdjf111111ksd";//指定需要操作的字符串数据
		Matcher matcher=pattern.matcher(s);//将字符串和正则对象进行匹配
		while(matcher.find()){//如果匹配器返现了输入字符串中有满足匹配器条件的字符串时会返回true
			System.out.println(matcher.group());//输出满足匹配器的字符串
		}
	}
}

Math类

用来描述数学中一些基本算法，都是静态方法和静态常量。
常量：PI（圆周率）、E（自然底数）
方法：ceil, floor, abs, cbrt, pow, max, min, random, round, sqrt

import java.util.Random;

public class Demo2 {
//ceil(向上取整),floor(向下取整),abs(absolute value),sqrt(square root),cbrt(cbue root),pow,max,min,random,round
	public static void main(String[] args) {
		// ceil方法，向上取整,返回的还是一个double类型的数据(无论正负)
		double a = 3.14;
		double b = Math.ceil(a);
		System.out.println(b);
		//floor方法，向下取整，返回的还是一个double类型数据（无论正负）
		double c=Math.floor(a);
		System.out.println(c);
		//abs方法，去绝对值
		int d=-110;float e=-1.11f;
		System.out.println(Math.abs(d));
		System.out.println(Math.abs(e));
		//sqrt方法，开平方,返回double类型的小数
		System.out.println(Math.sqrt(222));
		//cbrt方法，开3次方,返回值类型是double
		System.out.println(Math.cbrt(8));
		//pow方法，pow(2,5)就计算2的5次方，double类型
		System.out.println(Math.pow(2, 5));
		//max方法，放回两个long值中较大的那个，注意是long类型
		System.out.println(Math.max(100, 105));
		//min方法，放回两个数中较小的那个，注意是long类型的
		System.out.println(Math.min(100, 99));
		//random方法，随机输出一个[0，1)，之间的double类型的16位小数随机数，可以等于0，但不会等于1
		System.out.println(Math.random());
		//注意，random还有一个自己的类，创建random对象可以自定义右边界，就不用强转操作了
		//random对象有多重方法可供选择
		Random x=new Random();
		int i=x.nextInt(10000000);
		System.out.println(i);

		//round方法，四舍五入,注意如果括号里是double则输出的是long类型的整数，如果是float则输出的是int类型整数
		System.out.println(Math.round(3.14F));
	}
}		System.out.println(Math.min(100, 99));
//random方法，随机输出一个[0，1)，之间的double类型的16位小数随机数，可以等于0，但不会等于1
		System.out.println(Math.random());
//注意，random还有一个自己的类，创建random对象可以自定义右边界
		//random对象有多重方法可供选择
		Random x=new Random();
		int i=x.nextInt(10000000);
		System.out.println(i);

//round方法，四舍五入,注意如果括号里是double则输出的是long类型的整数，如果是float则输出的是int类型整数
		System.out.println(Math.round(3.14F));
	}
}

System类

系统类，用来描述系统的一些信息。类中成员都是静态的，不能创建对象。
字段：
out：标准的输出流，默认关联控制台
in：标准的输入流，默认关联键盘
err：标准的错误输出流，默认关联控制台，不能控制输出的顺序，且红色显示
方法：
exit(int)：JVM退出，0为正常退出，非0表示异常退出。
gc()：启动垃圾回收器
currentimeMillis()：获取当前时间的毫秒值，起始时间为1970年1月1日。

import java.util.Properties;

public class Demo3 {
	public static void main(String[] args) {
		System.out.println("12");
		Properties prop=System.getProperties();//获取系统所有属性
		prop.list(System.out);
		System.out.println(System.currentTimeMillis());//返回当前系统时间的毫秒值，以1970年1月1日为起点，称为历年（epoch）
		System.exit(0);//0为正常退出，否则为非正常退出
	}
}

日期对象

import java.util.Date;
//日期对象不是Object类的，需要导包
public class Demo4 {
	public static void main(String[] args) {
		//创建一个日期对象
		Date a=new Date();//第一构造方法
		System.out.println(a);
		Date b=new Date(System.currentTimeMillis());//第二构造方法Date(long date)，给一个毫秒值用次方法就可以转为系统默认日期格式
		System.out.println(b);
		Date c=new Date(1998321);//手动输入毫秒值
		System.out.println(c);
	}
}

DateFormat方法

DateFormat 是日期/时间格式化子类的抽象类（DateFormat他本身不能创建对象，可以用DateFormat.getInstance() 方法获得一个实例，相当于创建了对象），它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年 1 月 1 日 00:00:00 这一刻开始的毫秒数。

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo5 {	//instance-实例 instantiate-实例化
	public static void main(String[] args) {
		String s="1234";
		//得到格式化器
		DateFormat a=DateFormat.getInstance();//DateFormat是抽象类不能创建对象，必须使用getInstance方法
		//然后调用DateFormat的方法format进行格式化日期，格式化后的日期是默认格式的
		//DateFormat中的format(Date date)是将一个日期对象格式化成日期/时间字符串
		String time =a.format(new Date());
		System.out.println(time);
		//怎么转换成自己想要的格式：用SimpleDateFormat类，注意yyyy年中的y不能写成具体的数字
		SimpleDateFormat c=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss:SSS E");
		Date d=new Date();
		String e=c.format(new Date());
		System.out.println(e);
		//setTime方法void返回类型的，直接用对象调用使用即可，不用=左边的部分,作用是返回这个毫秒值对应的日期
		Date date=new Date();
		System.out.println(date);
		//获取当前时间的毫秒值
		long time1=date.getTime();
		//毫秒值加一天
		time1+=1000*3600*24;
		date.setTime(time1);
		System.out.println(date);
	}
}

计算自己从出生到现在总共过了多少天

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

//流程：先把两个时间都转换成毫秒形式，然后相减，在转换成天数
public class Dmeo1{	//计算出生到现在总共多少天
	public static void main(String[] args) throws ParseException{
		String birthday="1993年01月01日";
		//把生日转换成毫秒
		/*首先他要是一个日期对象，然后转换成毫秒，但是默认的格式肯定不是我们输入的格式，那么就要先转换成我们需要的
		 * 日期格式，要自定义输入的日期格式就要用到SimpleDateFormat方法	，所以先创建stf对象格式化文本数据*/
		SimpleDateFormat date=new SimpleDateFormat("yyyy年MM月dd日");
		//创建好一个格式化器之后我们就可以解析任意一个同格式的文本成对应的日期对象了
		Date date1=date.parse(birthday);
		//转换成日期对象之后就可以转换成毫秒格式了
		long time1=date1.getTime();
		//获取现在日期的毫秒格式
		long time2=System.currentTimeMillis();
		/*或者写成如下形式
		 * Date a=new Date();
		 * long time2=a.getTime();
		 */
		long time3=time2-time1;//差值
		long days=time3/1000/3600/24;//time是long格式的所以此处days也要定义成long格式的
		System.out.println("总共过了"+days+"天");
	}
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo5 {
	public static void main(String[] args) throws ParseException {
		//2016年01月02日 10:27:14与2019-11/12 10:27:14相隔多少单元
		
		//先创建他们对应的格式化器，把他们都放到格式化器中
		SimpleDateFormat sdf1=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM/dd HH:mm:ss");
		
		//解析成日期对象
		Date d1=sdf1.parse("2016年01月02日 10:27:14");
		Date d2=sdf2.parse("2019-11/12 10:27:14");
		
		//用Date方法获取他们对应的毫秒值,然后相减
		Long time1=d1.getTime();
		Long time2=d2.getTime();
		Long time3=time2-time1;
		
		System.out.println("相隔"+time3/1000/3600/24+"天");
	}
}

import java.util.Calendar;
//计算每一年的2月有多少天
public class Demo6 {
	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();//获取一个日历实例
		for (int year = 1000; year < 2555; year++) {//计算1000年到2554年之间每年的2月份有多少天
			cal.set(year, 2, 1);//设置当前年份的时间为3月1日，日历的月份是从0开始的
			cal.add(Calendar.DAY_OF_MONTH, -1);//给天数添加-1天，那么当前时间就是2月的最后一天
			
			//获取当前月份的字段属性，Calendar类的属性都是静态的，直接用类名.属性名调用即可
			System.out.println(year + "年的2月有 " + cal.get(Calendar.DAY_OF_MONTH) + "天");

		}
	}
}