JavaSE学习day14(正则表达式&常用工具类)

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/weixin_42135811/article/details/102258335

###14.01_常见对象(正则表达式的概述和简单使用)

• A:正则表达式

• 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
• 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的

• B:案例演示

• 需求：校验qq号码.
  • 1:要求必须是5-15位数字
  • 2:0不能开头
  • 3:必须都是数字
• a:非正则表达式实现
• b:正则表达式实现

###14.02_常见对象(字符类演示)

• A:字符类

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

###14.03_常见对象(预定义字符类演示)

• A:预定义字符类

• . 任何字符。
• \d 数字：[0-9]
• \w 单词字符：[a-zA-Z_0-9]

###14.04_常见对象(数量词)

• A:Greedy 数量词

• X? X，一次或一次也没有
• X* X，零次或多次
• X+ X，一次或多次
• X{n} X，恰好 n 次
• X{n,} X，至少 n 次
• X{n,m} X，至少 n 次，但是不超过 m 次

###14.05_常见对象(正则表达式的分割功能)

• A:正则表达式的分割功能

• String类的功能：public String[] split(String regex)

• B:案例演示

• 正则表达式的分割功能

public class Demo5_Split {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s = "ccc.mmm.ttt";
		String[] arr = s.split("\\.");				//通过正则表达式切割字符串	
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		System.out.println("11111111111111111");
    }
}

###14.06_常见对象(把给定字符串中的数字排序)

• A:案例演示

• 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

import java.util.Arrays;
public class Test1 {

/**
 * @param args
 * * A:案例演示
 * 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
 * 100
 * 80
 * 分析:
 * 1,将字符串切割成字符串数组
 * 2,将字符串转换成数字并将其存储在一个等长度的int数组中
 * 3,排序
 * 4,将排序后的结果遍历并拼接成一个字符串
 */

public static void main(String[] args) {
	String s = "91 27 46 38 50";
	//1,将字符串切割成字符串数组
	String[] sArr = s.split(" ");
	//2,将字符串转换成数字并将其存储在一个等长度的int数组中
	int[] arr = new int[sArr.length];
	for (int i = 0; i < arr.length; i++) {
		arr[i] = Integer.parseInt(sArr[i]); 	//将数字字符串转换成数字
	}
	
	//3,排序
	Arrays.sort(arr);
	
	//4,将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
	/*String str = "";
	for (int i = 0; i < arr.length; i++) {
		if(i == arr.length - 1) {
			str = str + arr[i];				//27 38 46 50 91
		}else {
			str = str + arr[i] + " ";		//27 38 46 50 
		}
	}
	
	System.out.println(str);*/
	
	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);
}
}

###14.07_常见对象(正则表达式的替换功能)

• A:正则表达式的替换功能

• String类的功能：public String replaceAll(String regex,String replacement)

• B:案例演示

• 正则表达式的替换功能

  public class Main {
  	  public static void main(String[] args){
 	 	 String s = "c1m2t3";
 	 	 String regex = "\\d";   //\\d代表的是任意数字
    	  String s2 = s.replaceAll(regex,"");
      	System.out.println(s2);
      }
}

###14.08_常见对象(正则表达式的分组功能)

• A:正则表达式的分组功能

• 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B©)) 中，存在四个这样的组：

•   1     ((A)(B(C))) 
    2     (A 
    3     (B(C)) 
    4     (C) 
  
    组零始终代表整个表达式。
  

• B:案例演示

• a:切割
  • 需求：请按照叠词切割： “sdqqfgkkkhjppppkl”;
• b:替换
  • 需求：我我…我…我.要…要要…要学…学学…学.编…编编.编.程.程.程…程
  • 将字符串还原成:“我要学编程”。
• 案例一：

public class Main {
    public static void main(String[] args){
 	    //叠词 快快乐乐，高高兴兴
  	    String regex = "(.)\\1(.)\\2";  
  		//\\1代表第一组又出现一次，\\2代表第二组又出现一次
        System.out.println("快快乐乐".matches(regex));   //true
        System.out.println("快乐乐乐".matches(regex));   //false
  	}
}

• 案例二：

public class Main {
    public static void main(String[] args){
        //叠词 快快乐乐，高高兴兴
        String regex = "(..)\\1";  //\\1代表第一组又出现一次
        System.out.println("高兴高兴".matches(regex));  //true
        System.out.println("快乐乐乐".matches(regex));  //false
   }
}

• 案例三：切割
  public class Main {
  public static void main(String[] args){
  String s = “sdqqfgkkkhjppppkl”;
  String regex = “(.)\1+”; //\1+代表第一组出现一次到多次
  String[] arr = s.split(regex);
  for (int i = 0; i < arr.length; i++){
  System.out.println(arr[i]);
  }
  }
  }

• 案例四：替换

public class Main {
    public static void main(String[] args){
        String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
        //不能使用.因为点代表任意字符，要用\\.，后面使用+代表出现一次到多次
 		String s2 = s.replaceAll("\\.+","");
  		System.out.println(s2);
  		String s3 = s2.replaceAll("(.)\\1+","$1");
  		//第二个参数代表获取到第一个组的数据把前面第一个参数的内容的替换掉,$1代表第一组中的内容
 		 System.out.println(s3);   //我要学编程
	}
}    

###14.09_常见对象(Pattern和Matcher的概述)

• A:Pattern和Matcher的概述
• B:模式和匹配器的典型调用顺序

• 通过JDK提供的API，查看Pattern类的说明
• 典型的调用顺序是
• Pattern p = Pattern.compile(“a*b”);
• Matcher m = p.matcher(“aaaaab”);
• boolean b = m.matches();

public class Main {
    public static void main(String[] args){
        Pattern p = Pattern.compile("a*b");  //获取到正则表达式
        Matcher m = p.matcher("aaaaab"); //获取匹配器
        boolean b = m.matches();      //看是否匹配，匹配返回true
 		System.out.println(b);
  		//以上代码就相当于以下这一行代码
  		System.out.println("aaaaab".matches("a*b"));//与上面的结果一样
 	}
}

###14.10_常见对象(正则表达式的获取功能)

• A:正则表达式的获取功能

• Pattern和Matcher的结合使用

• B:案例演示

• 需求：把一个字符串中的手机号码获取出来

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

public class Main {
  	public static void main(String[] args){
  		String s = "我的手机号码是18437395028,曾经用过18936739581，还用过13465464328";
 		String regex = "1[3578]\\d{9}";  //手机号码的正则表达式
		//  Pattern p  = Pattern.compile(regex);
		//  Matcher m = p.matcher(s);
		//  boolean b = m.matches();
		//  System.out.println(b);  //false
 		Pattern p  = Pattern.compile(regex);
  		Matcher m = p.matcher(s);
		//  boolean b1 = m.find();   //find方法为找到子序列
		//  System.out.println(b1);  //true
		//  String s1 = m.group();   //group方法为获取子序列
		//  System.out.println(s1);  //18437395028
  		//用循环找多个电话号码
  		while (m.find())
 		    System.out.println(m.group());
			//  18437395028
			//  18936739581
			//  13465464328
   	}
}

###14.11_常见对象(Math类概述和方法使用)

• A:Math类概述

• 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)

public class Main {
	public static void main(String[] args){
 		System.out.println(Math.PI);  //3.141592653589793
  		System.out.println(Math.abs(-10));//取绝对值10
  		System.out.println(Math.ceil(12.3));//向上取整但结果为double值13.0
  		System.out.println(Math.ceil(12.99));//向上取整但结果为double值13.0
  		System.out.println(Math.floor(12.3));//向下取整但结果为double值12.0
  		System.out.println(Math.floor(12.99));//向下取整但结果为double值12.0
  		System.out.println(Math.max(2,4));//获取最大值4
  		System.out.println(Math.pow(2,3));//前面的数为底数，后面为指数，2的3次方8
  		System.out.println(Math.random());//生成0.0-1.0之间的随机小数，包括0.0，不包括1.0
  		System.out.println(Math.round(12.3f));//四舍五入12
  		System.out.println(Math.round(12.5f));//四舍五入13
  		System.out.println(Math.sqrt(4));//开平方2
   	}
}

###14.12_常见对象(Random类的概述和方法使用)

• A:Random类的概述

• 此类用于产生伪随机数如果用相同的种子创建两个 Random 实例，
• 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

• B:构造方法

• public Random()
• public Random(long seed)

• C:成员方法

• public int nextInt()
• public int nextInt(int n)(重点掌握)

public class Main {
 	public static void main(String[] args){
  		Random r = new Random();
  		int x = r.nextInt();
  		int x1 = r.nextInt(100);//0-99之间的伪随机数
  		System.out.println(x);
  		System.out.println(x1);
   		}
	}

###14.13_常见对象(System类的概述和方法使用)

• A:System类的概述

• 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) //拷贝数组（原数组，原数组起始位置，目标数组，目标数组起始位置，要拷贝的长度）

• C:案例演示

• System类的成员方法使用

###14.14_常见对象(BigInteger类的概述和方法使用)

• A: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) 商和模的数组

import java.math.BigInteger;

public class Main {
   public static void main(String[] args){
   	   BigInteger b1 = new BigInteger("100");
  	   BigInteger b2 = new BigInteger("4");
  	   System.out.println(b1.add(b2));  //加 104
  	   System.out.println(b1.subtract(b2)); //减 96
   	   System.out.println(b1.multiply(b2)); //乘 400
  	   System.out.println(b1.divide(b2));  //除 25

  	   BigInteger[] arr = b1.divideAndRemainder(b2);
  	   for (int i = 0; i < arr.length; i++) {
 		   System.out.println(arr[i]);  //除数和余数 25 0
  	   }
   }
}

###14.15_常见对象(BigDecimal类的概述和方法使用)

• 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)

• D:案例演示

• BigDecimal类的构造方法和成员方法使用

import java.math.BigDecimal;

public class Main {
   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));  //0.9

       BigDecimal bd3 = BigDecimal.valueOf(2.0);
       //这种方式在开发中也是推荐的
       BigDecimal bd4 = BigDecimal.valueOf(1.1);
       System.out.println(bd3.subtract(bd4));  //0.9
   }
}

###14.16_常见对象(Date类的概述和方法使用)(掌握)

• A:Date类的概述

• 类 Date 表示特定的瞬间，精确到毫秒。
• 类 Date 是util包下的，不能导入sql包。

• B:构造方法

• public Date()
• public Date(long date)

• C:成员方法

• public long getTime()
• public void setTime(long time)

import java.util.Date;

public class Main {
    public static void main(String[] args){
   	    Date d1 = new Date();
        System.out.println(d1);
   		//Sun Oct 06 18:08:20 CST 2019

  		Date d2 = new Date(0);
  		System.out.println(d2);
  		//Thu Jan 01 08:00:00 CST 1970
  		//如果参数传为0代表1970年1月1日，如果没传参数则是当前时间
  		//其实系统时间依然是0点，只不过电脑时间设置为东8区，故打印结果是8点

  		System.out.println(d1.getTime());
  		//通过时间对象获取毫秒值
  		System.out.println(System.currentTimeMillis());
  		//通过系统类的方法获取当前时间毫秒值

  		Date d3 = new Date();
  		d3.setTime(1000); //设置毫秒值
  		System.out.println(d3);
  		//Thu Jan 01 08:00:01 CST 1970 因为1000毫秒等于1秒
   }
}

###14.17_常见对象(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)

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

public class Main {
    public static void main(String[] args){
  		//DateFormat df = new DateFormat();  //DateFormat是抽象类不能实例化
  		//DateFormat df1 = new SimpleDateFormat();
  		//DateFormat df1 = DateFormat.getDateInstance();
  		//相当于父类引用指向子类对象，右边的方法返回一个子类对象
  		Date d = new Date();//获取当前时间对象
  		SimpleDateFormat sdf = new SimpleDateFormat();//创建日期格式化类对象
  		System.out.println(sdf.format(d)); //19-10-6 下午6:36

  		Date d1 = new Date();//获取当前时间对象
  		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
  		//创建日期格式化类对象
  		System.out.println(sdf1.format(d1)); //2019年10月06日18:39:50

  		//将时间字符串转换为日期对象
  		String str = "2000年08月08日08时08分08秒";
  		SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
  		Date d2 = sdf2.parse(str);  //将时间字符串转换为日期对象   parse需要抛出异常
  		System.out.println(d);
   }
}

###14.18_常见对象(你来到这个世界多少天案例)(掌握)

• A:案例演示

• 需求：算一下你来到这个世界多少天?

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

/**
 * 1.将生日字符串和时间字符串存储在String类型的变量中
 * 2.定义日期格式化对象
 * 3.将日期字符串转换为日期对象
 * 4.通过日期对象获取时间毫秒值
 * 5.将两个时间毫秒值相减除以1000得到秒，再除60得到分，再除60得到时，再除24得到天
 */
public class Main {
    public static void main(String[] args) {
  		//1.将生日字符串和时间字符串存储在String类型的变量中
  		String birthday = "1997年05月20日";
  		String today = "2019年10月06日";
  		//2.定义日期格式化对象
  		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
  		//3.将日期字符串转换为日期对象
  		Date d1 = sdf.parse(birthday);
 		Date d2 = sdf.parse(today);
  		//4.通过日期对象获取时间毫秒值
  		long time = d2.getTime() - d1.getTime();
  		//5.将两个时间毫秒值相减得到天
  		System.out.println(time/1000/60/60/24);
    }
}

###14.19_常见对象(Calendar类的概述和获取日期的方法)(掌握)

• A:Calendar类的概述

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

• B:成员方法

• public static Calendar getInstance()
• public int get(int field)

import java.util.Calendar;

public class Main {
    public static void main(String[] args) {
  		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));//月中的第几天
  		System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一天，周六是最后一天

  		System.out.println(c.get(Calendar.YEAR)+"年"+ (c.get(Calendar.MONTH)+1)+"月"
  		+c.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(c.get(Calendar.DAY_OF_WEEK)));
  		//2019年10月6日星期日

  		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)));
  		//2019年10月06日星期日
    }

   /**
	* 将星期存储表中进行查表
	* 1.返回类型String
	* 2.参数列表int Week
	*/
    public static String getWeek(int week){
  		String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
  		return arr[week];
    }

   /**
	* 如果是个数数字前面补0
	* 1.返回值类型String类型
	* 2.参数列表int num
	*/
    public static String getNum(int num){
		//  if(num > 9){
		// return ""+num;
		//  }else{
		// return "0"+num;
		//  }
  		return num > 9 ? "" + num : "0" + num;
    }
}

###14.20_常见对象(Calendar类的add()和set()方法)(掌握)

• A:成员方法

• public void add(int field,int amount)
• public final void set(int year,int month,int date)

• B:案例演示1

• Calendar类的成员方法使用1

import java.util.Calendar;

public class Main {
    public static void main(String[] args) {
  		Calendar c = Calendar.getInstance(); //父类引用指向子类对象
  		c.add(Calendar.MONTH,-1);//给指定字段赋值为两参数之和
  		System.out.println(c.get(Calendar.YEAR)+"年"+ (c.get(Calendar.MONTH)+1)+"月"
  		+c.get(Calendar.DAY_OF_MONTH)+"日");
  		//2019年9月6日星期日
    }
}

• C:案例演示2

• Calendar类的成员方法使用2

import java.util.Calendar;

public class Main {
    public static void main(String[] args) {
  		Calendar c = Calendar.getInstance(); //父类引用指向子类对象
  		//c.set(Calendar.MONTH,2006);//修改指定字段 2019年9月6日星期日
  		c.set(2006,8,9);//修改指定字段 2006年9月9日
  		System.out.println(c.get(Calendar.YEAR)+"年"+ (c.get(Calendar.MONTH)+1)+"月"
  		+c.get(Calendar.DAY_OF_MONTH)+"日");
    }
}

###14.21_常见对象(如何获取任意年份是平年还是闰年)(掌握)

• A:案例演示

• 需求：键盘录入任意一个年份，判断该年是闰年还是平年

import java.util.Calendar;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
  		Scanner sc = new Scanner(System.in);
  		System.out.println("请输入年份，判断是闰年还是平年");

  		String line = sc.nextLine();
  		//录入数字字符串
  		int year = Integer.parseInt(line);
  		//将数字字符串转换为数字
  		boolean b = getYear(year);
  		System.out.println(b);
    }

    private  static  boolean getYear(int year){
  		Calendar c = Calendar.getInstance();
  		c.set(year,2,1);
  		c.add(Calendar.DAY_OF_MONTH,-1);
  		return c.get(Calendar.DAY_OF_MONTH) == 29;
    }
}