正则表达式 常用工具类

正则表达式

package haha;



public class Normal1 {

	public static void main(String[] args) {
		System.out.println(checkQQ("012345"));
		System.out.println(checkQQ("a1b345"));
		System.out.println(checkQQ("123456"));
		System.out.println(checkQQ("1234567890987654321"));
		
		String regex="[1-9]\\d{4,14}";
		//[1-9]任意一个数 //d任意数字字符{4,14}出现4到14次e
		System.out.println("2553868".matches(regex));
		System.out.println("0553868".matches(regex));

	}
	public static boolean checkQQ(String qq) {
		boolean flag = true;					//如果校验qq不符合要求就把flag置为false,如果符合要求直接返回
		
		if(qq.length() >= 5 && qq.length() <= 15) {
			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')) {
						flag = false;			//不是数字
						break;
					}
				}
			}else {
				flag = false;					//以0开头,不符合qq标准
			}
		}else {
			flag = false;						//长度不符合
		}
		return flag;
	}
}

常见对象字符类

package haha;



public class Normal1 {

	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		//demo4();
		String regex="[a-z&&[def]]";
		//a-z和def的交集  相当于def
		System.out.println("a".matches(regex));
	}

	private static void demo4() {
		String regex="[a-d[m-p]]";
				//a到b或m到p
	}

	private static void demo3() {
		String regex="[a-zA-Z]";
	}

	private static void demo2() {
		String regex="[^abc]";
		//除了abc任意一个字符
		System.out.println("10".matches(regex));
		System.out.println("1".matches(regex));
		//false true  10代表两个字符
	}

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

常见对象预定义字符类

package haha;



public class Normal1 {

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

	private static void demo2() {
		String regex="\\d";
		//转义字符 代表任意数字
		String regex2="\\D";
		//除了0-9
		String regex3="\\s";
		//空白字符 空格和tab是true 四个空格false
		String regex4="\\S";
		//非空白字符
		String regex5="\\w";
		//单词字符  字母和_和0-9
		String regex6="\\W";
		//非单词字符
	}

	private static void demo1() {
		String regex=".";
		//.代表任意字符
		System.out.println("a".matches(regex));
		System.out.println("ab".matches(regex));
		//true false
	}
}

常见对象数量词

package haha;



public class Normal1 {

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

	private static void demo4() {
		String regex="[abc]{5}";
		//恰好五次
		System.out.println("abcba".matches(regex));
		System.out.println("abcbaabcba".matches(regex));
		//true false
		String regex2="[abc]{5,}";
		//至少5次
		String regex3="[abc]{5,15}";
		//5次到15次 包含15次
	}

	private static void demo3() {
		String regex="[abc]+";
		//一次到多次
		System.out.println("".matches(regex));
		System.out.println("a".matches(regex));
		System.out.println("aaaaaaaa".matches(regex));
		//false true true
	}

	private static void demo2() {
		String regex="[abc]*";
		//代表0次到多次
		System.out.println("".matches(regex));
		System.out.println("abc".matches(regex));
		System.out.println("a".matches(regex));
		//3true
	}

	private static void demo1() {
		String regex="[abc]?";
		//一次或者一次也没有
		System.out.println("a".matches(regex));
		System.out.println("d".matches(regex));
		//true false 一次也没有但是不能出现别的
		System.out.println("".matches(regex));
		System.out.println(" ".matches(regex));
		//true false
	}
}

正则表达式的分割功能

package haha;



public class Normal1 {

	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 i = 0; i < arr2.length; i++) {
		System.out.println(arr2[i]);
	}
	}
}

把给定字符串中的数排序

package haha;

import java.util.Arrays;

public class Normal1 {

	public static void main(String[] args) {
		String s="91 27 46 38 50";
		String[] sArr=s.split(" ");
		
		int[] arr=new int[sArr.length];
		for (int i = 0; i < arr.length; i++) {
			arr[i]=Integer.parseInt(sArr[i]);
		}
		
		
		Arrays.sort(arr);
		
		
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < arr.length; i++) {
			if(i == arr.length - 1) {
				sb.append(arr[i]);
			}else {
				sb.append(arr[i] + " ");
			}
		}
		
		System.out.println(sb);
	}
	
}

正则表达式替换功能

package haha;

import java.util.Arrays;

public class Normal1 {

	public static void main(String[] args) {
		String s="wo1ai2heima";
		String regex="\\d";
		
		String s2=s.replaceAll(regex, "");
		System.out.println(s2);
		//woaiheima
	}
	
}

正则表达式分组功能

package haha;

import java.util.Arrays;
/**
 * * A:正则表达式的分组功能
		* 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 
	* 
			1     ((A)(B(C))) 
			2     (A 
			3     (B(C)) 
			4     (C) 
		
			组零始终代表整个表达式。
	B:案例演示
		a:切割
			需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
		b:替换
			需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
			将字符串还原成:“我要学编程”。
 */
public class Normal1 {

	public static void main(String[] args) {
		//demo1();
		//demo2();
		//需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
		//将字符串还原成:“我要学编程”。
		String s="我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
        String s2=s.replaceAll("\\.+","");
        System.out.println(s2);
        //我我我我要要要要学学学学编编编编程程程程
        
        String s3=s2.replaceAll("(.)\\1+", "$1");
        //$1代表第一组中的内容   一个我替换所有我 一个要替换所有要
        System.out.println(s3);
	}

	private static void demo2() {
		//	需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
		String s="sdqqfgkkkhjppppkl";
		String regex="(.)\\1+";
		//出现一次或多次
		String[] arr=s.split(regex);
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
//		sd
//		fg
//		hj
//		kl
	}

	private static void demo1() {
		//叠词 高高兴兴
		String regex="(.)\\1（.）\\2";
		//(.)第一组 \\1第一组又出现一次 \\2第二组出现一次
		System.out.println("快快乐乐".matches(regex));
		System.out.println("快乐乐乐".matches(regex));
		System.out.println("高高兴兴".matches(regex));
		//true false true
		
		//死啦死啦
		String regex2="(..)\\1";
		System.out.println("死啦死啦".matches(regex2));
	}
	
}

Parttern Matcher

package haha;

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

public class Normal1 {

	public static void main(String[] args) {
		//demo1(); 
		String s = "我的手机是18511866260,我曾用过18987654321,还用过18812345678";
		String regex = "1[3578]\\d{9}";
//		Pattern p = Pattern.compile(regex);
//		 Matcher m = p.matcher(s);
//		 boolean b = m.matches();
		 //false
		
		
		 Pattern p = Pattern.compile(regex);
		 Matcher m = p.matcher(s);
		
		 while(m.find())
			 System.out.println(m.group());
//		 18511866260
//		 18987654321
//		 18812345678
	}

	private static void demo1() {
		Pattern p = Pattern.compile("a*b");
		//获取到正则表达式
		 Matcher m = p.matcher("aaaaab");
		 //获取匹配器
		 boolean b = m.matches();
		 
		 System.out.println("aaaaab".matches("a*b"));
	}
	
}

Math类

• B:成员方法
  • public static int abs(int a)
  • public static double ceil(double a)
  • public static double floor(double a)
  • public static int max(int a,int b) min自学
  • public static double pow(double a,double b)
  • public static double random()
  • public static int round(float a) 参数为double的自学
  • public static double sqrt(double a)

package haha;

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

public class Normal1 {

	public static void main(String[] args) {
		System.out.println(Math.PI);
		System.out.println(Math.abs(-10));
		//绝对值 10
		System.out.println(Math.ceil(12.3));
		System.out.println(Math.ceil(12.99));
		//天花板 13.0 13.0
		System.out.println(Math.floor(12.3));
		System.out.println(Math.floor(12.99));
		//12.0 12.0
		
		System.out.println(Math.max(20, 30));
		//30
		System.out.println(Math.pow(2, 3));
		//8.0
		
		System.out.println(Math.random());
		
		System.out.println(Math.round(12.3f));
		System.out.println(Math.round(12.9f));
		//四舍五入 12 13
		
		System.out.println(Math.sqrt(4));
		System.out.println(Math.sqrt(2));
		//开平方
	}
	
}

Random类

• B:构造方法
  • public Random()
  • public Random(long seed)
• C:成员方法
  • public int nextInt()
  • public int nextInt(int n)(重点掌握)

//	  demo1();
//	  demo2();
		Random r3=new Random();
		for (int i = 0; i < 10; i++) {
			System.out.println(r3.nextInt(100));
			//0到 99
		}
	}

	private static void demo2() {
		Random r2=new Random(1000);
		  int a=r2.nextInt();
		  int b=r2.nextInt();
		  
		  System.out.println(a);
		  System.out.println(b);
		  // 运行多次 ab不变
	}

	private static void demo1() {
		Random r=new Random();
//	  int x=r.nextInt();
//	  System.out.println(x);
		  for (int i = 0; i < 10; i++) {
			System.out.println(r.nextInt());
			
		}

System类

• B:成员方法
  • public static void gc()
  • public static void exit(int status)
  • public static long currentTimeMillis()
  • pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

package haha;

import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Normal1 {

	public static void main(String[] args) {
	//demo1();
	//demo2();
	//	demo3();
		int[] src={11,22,33,44,55};
		int[] dest=new int[8];
	
		for (int i = 0; i < dest.length; i++) {
			System.out.print(dest[i]+" ");
			//0 0 0 0 0 0 0 0
			
		}
		System.arraycopy(src, 0, dest, 0, src.length);
		for (int i = 0; i < dest.length; i++) {
			System.out.print(dest[i]+" ");
			//11 22 33 44 55 0 0 0
			//将数组内容拷贝
			
		}
	}

	private static void demo3() {
		long start=System.currentTimeMillis();
		for(int i=0;i<1000;i++)
		{
			System.out.println("*");
		}
	       long end =System.currentTimeMillis();
	       System.out.println(end-start);
	       //毫秒 获取当前时间毫秒值
	}

	private static void demo2() {
		System.exit(0);
		//退出java虚拟机
		System.out.println("1111111");
	}

	private static void demo1() {
		for(int i=0;i<100;i++)	
			{
		      	new Demo();
		      	System.gc();
		      	//清理垃圾
			}
	}
	
}
class Demo
{

	@Override
	public void finalize() {
		
		System.out.println("垃圾被清扫了");
	}
	
} 

BigInteger类

• 超过integer的数进行运算
• B:构造方法
  • public BigInteger(String val)
• C:成员方法
  • public BigInteger add(BigInteger val)
  • public BigInteger subtract(BigInteger val)
  • public BigInteger multiply(BigInteger val)
  • public BigInteger divide(BigInteger val)
  • public BigInteger[] divideAndRemainder(BigInteger val)

public class Normal1 {

	public static void main(String[] args) {
	// String s="123456789098765432123";
	 BigInteger bi1=new BigInteger("100");
	 BigInteger bi2=new BigInteger("2");
	 System.out.println(bi1.add(bi2));
	 System.out.println(bi1.subtract(bi2));
	 System.out.println(bi1.multiply(bi2));
	 System.out.println(bi1.divide(bi2));
	 
	 BigInteger[] arr=bi1.divideAndRemainder(bi2);
	 for (int i = 0; i< arr.length; i++) {
		 System.out.println(arr[i]);
		 //50 0 除数 和余数
		
	}

	}
} 

BigDemical类

• A:BigDecimal的概述
  • 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
  • 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal
  • 不可变的、任意精度的有符号十进制数。
• B:构造方法
  • public BigDecimal(String val)
• C:成员方法
  • public BigDecimal add(BigDecimal augend)
  • public BigDecimal subtract(BigDecimal subtrahend)
  • public BigDecimal multiply(BigDecimal multiplicand)
  • public BigDecimal divide(BigDecimal divisor)

public class Normal1 {

	public static void main(String[] args) {
	 //System.out.println(2.0-1.1);
	 //0.8999999999999999
//		BigDecimal bd1= new BigDecimal(2.0);
//		BigDecimal bd2= new BigDecimal(1.1);
//		System.out.println(bd1.subtract(bd2));
		//还是不够精确
//		BigDecimal bd1= new BigDecimal("2.0");
//		BigDecimal bd2= new BigDecimal("1.1");
//		System.out.println(bd1.subtract(bd2));
		//0.9
		BigDecimal bd1= BigDecimal.valueOf(2.0);
		BigDecimal bd2= BigDecimal.valueOf(1.1);
		System.out.println(bd1.subtract(bd2));
//0.9
	}
} 

Date类

• A:Date类的概述
  • 类 Date 表示特定的瞬间，精确到毫秒。
• B:构造方法
  • public Date()
  • public Date(long date)
• C:成员方法
  • public long getTime()
  • public void setTime(long time)

public class Normal1 {

	public static void main(String[] args) {
		Date d1=new Date();
		System.out.println(d1);
		//Sun Mar 17 11:25:11 CST 2019
		
		Date d2=new Date(0);
		System.out.println(d2);
		//Thu Jan 01 08:00:00 CST 1970
		
		Date d3=new Date();
		System.out.println(d3.getTime());
		System.out.println(System.currentTimeMillis());
		//1552793401311
		//1552793401311
		
		Date d4=new Date();
	    d3.setTime(1000);
	    System.out.println(d4);
	    //Sun Mar 17 11:31:10 CST 2019
	}
} 

SimpleDateFormat类

• A:DateFormat类的概述
  • DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
• B:SimpleDateFormat构造方法
  • public SimpleDateFormat()
  • public SimpleDateFormat(String pattern)
• C:成员方法
  • public final String format(Date date)
  • public Date parse(String source)

public class Normal1 {

	public static void main(String[] args) throws ParseException {
	//	demo1();
		Date d=new Date();
		SimpleDateFormat sdf=new SimpleDateFormat();
		System.out.println(sdf.format(d));
		//19-3-17 上午11:38
		
		SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");;
		System.out.println(sdf2.format(d));
		//2019年03月17日11:40:37
		
		//时间字符串转换为日起对象
		String str="2000年08月08日 08:08:08";
		SimpleDateFormat sdf3 =new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
		Date d1=sdf3.parse(str);
		System.out.println(d1);
		//Tue Aug 08 08:08:08 CST 2000
	}

	private static void demo1() {
		//DataFormat抽象类 不能实例化
		DateFormat df1= DateFormat.getDateInstance();//相当于父类引用指向子类对象 右边的方法返回一个子类
	}
} 

你来到世界上多少天

public class Normal1 {

	public static void main(String[] args) throws ParseException {
         String birthday="1996年10月07日";
         String today="2019年03月17日";
         
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");
         Date d1=sdf.parse(birthday);
         Date d2=sdf.parse(today);
         
         long time= d2.getTime()-d1.getTime();
         System.out.println(time /1000 /60/60/24);
         //8196
	}
} 

Calendar类

• A:Calendar类的概述
  • Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
• B:成员方法
  • public static Calendar getInstance()
  • public int get(int field)

public class Normal1 {

	public static void main(String[] args) throws ParseException {
        Calendar c=Calendar.getInstance();
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH));
        //月从0开始
        System.out.println(c.get(Calendar.DAY_OF_MONTH));//17
        System.out.println(c.get(Calendar.DAY_OF_WEEK));
        
		//1 星期日是第一天 星期六是最后一天
		//c.add(Calendar.MONTH, -1);					//对指定的字段进行向前减或向后加
		//c.set(Calendar.YEAR, 2000);					//修改指定字段
		c.set(2000, 7, 8);
        
		System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1)) 
		+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
	}
	public static String getWeek(int week)
	{
		String[] arr={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
		return arr[week];
	}
	public static String getNum(int num) {
		/*if(num > 9) {
			return "" + num;
		}else {
			return "0" + num;
		}*/
		return num > 9 ? "" + num : "0" + num;
	}
} 

• A:成员方法
  • public void add(int field,int amount)
  • public final void set(int year,int month,int date)

判断平年瑞年

public class Normal1 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入年份,判断该年份是闰年还是平年:");
		//int year = sc.nextInt();
		
		String line = sc.nextLine();				//录入数字字符串
		int year = Integer.parseInt(line);			//将数字字符串转换成数字
		boolean b = getYear(year);
		System.out.println(b);
	}

	private static boolean getYear(int year) {
		//2,创建Calendar c = Calendar.getInstance();
		Calendar c = Calendar.getInstance();
		//设置为那一年的3月1日
		c.set(year, 2, 1);
		//将日向前减去1
		c.add(Calendar.DAY_OF_MONTH, -1);
		//判断是否是29天
		return c.get(Calendar.DAY_OF_MONTH) == 29;
	}

}