初学Java基础---Day21---正则表达式,日期类，Math类，Random类，System类，Runtime类，大数值运算类，

一，正则表达式

理解：

符合某个语句规范的字符串

案例：

//案例：把一个字符串中带电话号码替换成 130****1111 的形式

String str= "小红 13012341111 小绿15112342222 小黑13912343333";

//分析：电话号码可以分为三组如： (130)(1234)(1111) 其中第一组中的1是固定
//的，用正则表达式可以写成：(1\\d{2})(\\d{4})(\\d{4})

String regex ="(1\\d{2})(\\d{4})(\\d{4})";
str = str.replaceAll(regex,"$1****$3");// $n 表示保留第n组正则表达式里的数据

小结：正则表达式可以做替换功能

//案例: 利用正则表达式验证邮箱如：[email protected] 其中@前面数字在4-11位

String email ="[email protected]";
String regex = "\\d{4,11}@qq.com";
boolean matches =email.matches(regex);
sout(matches);

小结：正则表达式可以做验证

//案例:Pattern+Matcher 找到前端代码中的图片路径
public class Test04 {
	/**
	 * 知识点：正则表达式
	 * 理解：符合某个语句规范的字符串
	 * 
	 * 案例：Pattern+Matcher 找到前端代码中的图片路径
	 * 
	 * 小结：利用正则表达式做字符串的爬数据的工作
	 */
	public static void main(String[] args) {
		
		String str = "<img src='hhy/aaa.jpg'/><div><div/> <input type='image' src='submit.gif' /><img src='bbb.jpg'/>";
		
		String regex = "<img\\b[^>]*\\bsrc\\b\\s*=\\s*('|\")?([^'\"\n\r\f>]+(\\.jpg)\\b)[^>]*>";
		
		//获取正则表达式对象
		Pattern pattern = Pattern.compile(regex);
		//获取匹配结果
		Matcher matcher = pattern.matcher(str);
		
		//循环遍历匹配结果
		while(matcher.find()){
			//获取匹配结果
			String group = matcher.group(2);//2表示第2组数据
			System.out.println(group);
		}
		
	}
}

二，日期类

知识点：日期时间类

Date(java.util) ---日期类

SimpleDateFormat --格式化日期类

Calendar ---日历类

案例：

public class Test01 {
	/**
	 * 知识点：日期时间类
	 * 		Date（java.util） -- 日期类
	 * 		SimpleDateFormat -- 格式化日期类
	 * 		Calendar -- 日历类
	 */
	public static void main(String[] args) {
		
		Date date = new Date();
		
		//星期 月份 日期 时:分:秒 时区 年份
		//Sat Jan 27 14:31:41 CST 2024
		System.out.println(date);
	}
}

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

public class Test02 {
	/**
	 * 知识点：日期时间类
	 * 		Date（java.util） -- 日期类
	 * 		SimpleDateFormat -- 格式化日期类
	 * 		Calendar -- 日历类
	 */
	public static void main(String[] args) throws ParseException {
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
		
		//Date 转 String
		String datetime = sdf.format(new Date());
		System.out.println(datetime);
		
		//String 转 Date 
		Date date = sdf.parse("2024年01月27日 14时37分61秒");
		System.out.println(date);
	}
}

import java.util.Calendar;

public class Test03 {
	/**
	 * 知识点：日期时间类
	 * 		Date（java.util） -- 日期类
	 * 		SimpleDateFormat -- 格式化日期类
	 * 		Calendar -- 日历类
	 * 
	 */
	public static void main(String[] args) {
		
		//获取当前系统的日历对象
		Calendar c = Calendar.getInstance();
	
		int year = c.get(Calendar.YEAR);
		int month = c.get(Calendar.MONTH)+1;//注意：月份0~11，0表示1月，所以加个1
		int day = c.get(Calendar.DAY_OF_MONTH);
		int hour = c.get(Calendar.HOUR);
		int minute = c.get(Calendar.MINUTE);
		int second = c.get(Calendar.SECOND);
		
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(hour);
		System.out.println(minute);
		System.out.println(second);
	}
}

小结：

1.Date + SimpleDateFormat一起使用，获取我们想要的日期时间格式

2.获取单个日历信息，考虑使用Calendar

三，Math类及静态导入

Math 类提供了一序列基本数学运算和几何函数的方法。

Math类是final类，并且它的所有成员变量和成员方法都是静态的。

1.Math类的常量和常用方法

public class Test01 {
	/**
	 * 知识点：Math类
	 * 
	 * Math 类提供了一序列基本数学运算和几何函数的方法。
	 * Math类是final类，并且它的所有成员变量和成员方法都是静态的。
	 */
	public static void main(String[] args) {
		
		System.out.println("求次方：" + Math.pow(3, 2));//9.0
		System.out.println("求平方根：" + Math.sqrt(9));//3.0
		System.out.println("求绝对值：" + Math.abs(-100));//100
		System.out.println("求最大值：" + Math.max(10, 20));//20
		System.out.println("求最小值：" + Math.min(10, 20));//10
		System.out.println("向下取整（地板）：" + Math.floor(1.9));//1.0
		System.out.println("向上取整（天花板）：" + Math.ceil(1.1));//2.0
		System.out.println("四舍五入：" + Math.round(1.5));//2
		System.out.println("获取随机值：" + Math.random());//注意：随机出0~1的数字，0包含，1排他
		
		//需求：随机出1~100的数字
		int num = (int)(Math.random()*100)+1;
		System.out.println("获取随机值：" + num);
	}
}

2.面试题

//面试题：Math.abs会出现负数吗？
public class Test02 {
	/**
	 * 知识点：Math类
	 */
	public static void main(String[] args) {
		
		//获取int类型的最大值 -> 2147483647 -- 2的31次方-1
		System.out.println(Integer.MAX_VALUE);
		//获取int类型的最小值 -> -2147483648 - -2的31次方
		System.out.println(Integer.MIN_VALUE);
		
		//面试题：Math.abs会出现负数吗？
		//会出现负数 --> -2147483648
		System.out.println(Math.abs(-2147483648));
	}
}

3.静态导入

知识点：静态导入

理解：将类中所有的静态属性和方法都导入到本类来，作为本来自己的静态属性和方法

缺点：如果类中的方法和静态导入类中的方法重名了，会调用本类自己的静态方法，所以可读性差，不建议使用

//静态导入：将类中所有的静态属性和方法都导入到本类来，作为本来自己的静态属性和方法
import static java.lang.Math.*;

public class Test03 {
	/**
	 * 知识点：静态导入
	 * 理解：将类中所有的静态属性和方法都导入到本类来，作为本来自己的静态属性和方法
	 * 缺点：如果类中的方法和静态导入类中的方法重名了，会调用本类自己的静态方法，所以可读性差，不建议使用
	 */
	public static void main(String[] args) {
		
		System.out.println("求次方：" + pow(3, 2));//9.0
		System.out.println("求平方根：" + sqrt(9));//3.0
	}
	
	public static int sqrt(int i){
		return 123456;
	}
}

四，Random类

理解：随机类

import java.util.Random;

public class Test01 {
	/**
	 * 知识点：Random
	 * 理解：随机类
	 */
	public static void main(String[] args) {
		
		Random ran = new Random();
		
		System.out.println("随机出int取值范围里的数值：" + ran.nextInt());
		System.out.println("随机出0~9的int数值：" + ran.nextInt(10));
		System.out.println("随机出double取值范围里的数值：" + ran.nextDouble());
		System.out.println("随机出boolean取值范围里的数值：" + ran.nextBoolean());
	}
}

2.深入

import java.util.Random;

public class Test02 {
	/**
	 * 知识点：深入Random
	 * 
	 * 注意：seed叫做种子数，种子数一旦固定随机出的数字就是固定的！！！
	 */
	public static void main(String[] args) {
		
		Random ran = new Random(1000);
		System.out.println("随机出int取值范围里的数值：" + ran.nextInt());
		System.out.println("随机出0~9的int数值：" + ran.nextInt(10));
		
		
		System.out.println("--------------------");
		
		MyRandom myRandom = new MyRandom();
		System.out.println("随机出int取值范围里的数值：" + myRandom.nextInt());
		System.out.println("随机出0~9的int数值：" + myRandom.nextInt(10));
	}
}

public class MyRandom {
	
	//种子数
	private long seed;
	
	public MyRandom() {
		
		this(seedUniquifier() ^ System.nanoTime());
		
	}
	
	private static long seedUniquifier() {
        for (;;) {
            long current = System.currentTimeMillis();
            long next = current * 181783497276652981L;
            if (next%3==0 || next%12==0 || next%17==0){
                return next;
            }
        }
    }

	public MyRandom(long seed) {
		this.seed = seed;
	}
	
	public int nextInt(){
		return (int) seed;
	}
	
	public int nextInt(int bound){
		return Math.abs((int) seed)%bound;
	}
}

五，System类

理解：

Java程序的运行平台

1、 System类提供了一些静态属性和方法，允许通过类名直接调用。

2、 System类提供了代表标准输入、标准输出、错误输出的类属性。

3.System类提供了一些静态方法用于访问环境变量、系统属性的方法。

System类属性

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

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;

public class Test01 {
	/**
	 * 知识点：System - 属性
	 * 
	 */
	public static void main(String[] args) {
		
		//获取系统标准的输入流 - 方向：控制台->程序
		InputStream in = System.in;
		
		Scanner scan = new Scanner(in);
		System.out.println("请输入int值：");
		int num = scan.nextInt();
		
		//获取系统标准的输出流 - 方向：程序 -> 控制台
//		PrintStream out = System.out;
//		out.println(num);
		
		//获取系统标准的错误输出流 - 方向：程序 -> 控制台
		PrintStream err = System.err;
		err.println(num);
		
		scan.close();
	}
}

System.out 和 System.err 的区别

public class Test02 {
	/**
	 * 知识点：System.out和System.err的区别
	 * 
	 * 注意：稍微感受多线程抢资源的场景
	 */
	public static void main(String[] args) {
		
		System.out.println("小明");
		System.err.println("小红");
		System.out.println("小强");
	}
}

System 的方法

import java.util.Properties;

public class Test03 {
	/**
	 * 知识点：System - 方法
	 */
	public static void main(String[] args) {
		
		long currentTimeMillis = System.currentTimeMillis();
		System.out.println("获取自1970年1月1日到现在的毫秒数：" + currentTimeMillis);
		
		//获取系统参数
		Properties properties = System.getProperties();
		System.out.println(properties);
		
		//通过具体Key获取对应的Value
		String property = System.getProperty("os.name");
		System.out.println("通过具体Key获取对应的Value：" + property);
		
		//拷贝数组
		int[] arr = {1,2,3,4,5,6,7,8,9,10};
		int[] newArr = new int[4];
		System.arraycopy(arr, 3, newArr, 0, 4);//(源数组，开始下标，目标数组，开始下标，拷贝长度)
		for (int num : newArr) {
			System.out.println(num);
		}
		
		//利用System.arraycopy做数组的删除功能
		String[] names = {"aaa","bbb","ccc","ddd","eee","fff",null,null,null};	
		System.arraycopy(names, 2, names, 1, 4);
		names[5] = null;
		for (String str : names) {
			System.out.println(str);
		}
		
		//退出当前虚拟机，0表示正常退出
		System.exit(0);
	}

六，RunTime类

理解：Runtime表示运行时系统(JVM)

public class Test01 {
	/**
	 * 知识点：Runtime
	 * 理解：Runtime表示运行时系统(JVM)
	 */
	public static void main(String[] args) {
		
		//获取运行时系统对象
		Runtime run = Runtime.getRuntime();
		
		System.out.println("获取最大操作数：" + run.availableProcessors());//8
		System.out.println("获取最大内存数(byte)：" + run.maxMemory());
		System.out.println("获取闲置内存数(byte)：" + run.freeMemory());
		
	}
}

用途：程序的效率测试

public class Test02 {
	/**
	 * 知识点：程序的效率（时间、内存）
	 */
	public static void main(String[] args) {
		
//		Runtime run = Runtime.getRuntime();
//		long startTime = System.currentTimeMillis();
//		long startMemory = run.freeMemory();
//		String str = "莹莹";
//		for (int i = 1; i < 50000; i++) {
//			str += "小可爱，皇冠给你带";
//		}
//		long endMemory = run.freeMemory();
//		long endTime = System.currentTimeMillis();
//		System.out.println("消耗时长：" + (endTime-startTime));//6640
//		System.out.println("消耗内存：" + (startMemory-endMemory));
		
		System.out.println("--------------------------------------------");
		
//		Runtime run = Runtime.getRuntime();
//		long startTime = System.currentTimeMillis();
//		long startMemory = run.freeMemory();
//		StringBuffer sb = new StringBuffer("莹莹");
//		for (int i = 1; i < 50000; i++) {
//			sb.append("小可爱，皇冠给你带");
//		}
//		long endMemory = run.freeMemory();
//		long endTime = System.currentTimeMillis();
//		System.out.println("消耗时长：" + (endTime-startTime));//5
//		System.out.println("消耗内存：" + (startMemory-endMemory));//2293808
		
		System.out.println("--------------------------------------------");
		
		Runtime run = Runtime.getRuntime();
		long startTime = System.currentTimeMillis();
		long startMemory = run.freeMemory();
		StringBuffer sb = new StringBuffer(450060);//优化方案：减少底层扩容次数
		sb.append("莹莹");
		for (int i = 1; i < 50000; i++) {
			sb.append("小可爱，皇冠给你带");
		}
		long endMemory = run.freeMemory();
		long endTime = System.currentTimeMillis();
		System.out.println("消耗时长：" + (endTime-startTime));//5
		System.out.println("消耗内存：" + (startMemory-endMemory));//900136
	}
}

七，大数值运算类

BigInteger：

整数大数值运算类

当整数运算超出int类型的取值范围时

知识点：BigInteger - 整数大数值运算类

import java.math.BigInteger;

public class Test01 {
	/**
	 * 知识点：BigInteger - 整数大数值运算类
	 */
	public static void main(String[] args) {
		
		BigInteger big1 = new BigInteger("2100000000");
		BigInteger big2 = new BigInteger("2100000000");
		
		BigInteger add = big1.add(big2);
System.out.println("加法：" + add);//结果是字符串类型，底层是toString
		
		BigInteger subtract = big1.subtract(big2);
		System.out.println("减法：" + subtract);
		
		BigInteger multiply = big1.multiply(big2);
		System.out.println("乘法：" + multiply);
		
		BigInteger divide = big1.divide(big2);
		System.out.println("除法：" + divide);
	}
}

知识点：BigDecimal - 小数大数值运算类

注意： * 1.小数做运算会失去精度，所以小数做运算都要生成大数值的运算类 * 2.构造方法里的值使用字符串(即得用引号)

import java.math.BigDecimal;

public class Test02 {
	/**
	 * 知识点：BigDecimal - 小数大数值运算类
	 * 注意：
	 * 		1.小数做运算会失去精度，所以小数做运算都要生成大数值的运算类
	 * 		2.构造方法里的值使用字符串
	 */
	public static void main(String[] args) {
		
		BigDecimal big1 = new BigDecimal("0.5");
		BigDecimal big2 = new BigDecimal("0.4");
		
		BigDecimal add = big1.add(big2);
		System.out.println("加法：" + add);
		
		BigDecimal subtract = big1.subtract(big2);
		System.out.println("减法：" + subtract);
		
		BigDecimal multiply = big1.multiply(big2);
		System.out.println("乘法：" + multiply);
		
		BigDecimal divide = big1.divide(big2);
		System.out.println("除法：" + divide);
	}
}

//当计算出无限循环小数或者无限不循环小数时，需要用BigDecimal其他的重载方法
import java.math.BigDecimal;

public class Test03 {
	/**
	 * 知识点：BigDecimal - 小数大数值运算类
	 */
	public static void main(String[] args) {
		
		BigDecimal big1 = new BigDecimal("10");
		BigDecimal big2 = new BigDecimal("3");
		
		BigDecimal divide = big1.divide(big2, 3, BigDecimal.ROUND_HALF_UP);// Big1/Big2 保留3为小数，四舍五入
		System.out.println("除法：" + divide);
	}
}