初学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组正则表达式里的数据

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

//案例: 利用正则表达式验证邮箱如：8928398@qq.com 其中@前面数字在4-11位

String email ="8928398@qq.com";
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类属性

staticPrintStream	err “标准”错误输出流。
staticInputStream	in “标准”输入流。
staticPrintStream	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);
}
}

原文地址：https://blog.csdn.net/2401_87491344/article/details/143534000

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！