JavaEE基础知识

一、正则表达式

正则表达式常用文档

字符
x	字符 x
//	反斜线字符
/t	制表符 ('/u0009')
/n	新行（换行）符 ('/u000A')
/r	回车符 ('/u000D')
/e	转义符 ('/u001B')
.	任意字符

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

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

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

Logical 运算符
XY	X 后跟 Y
X|Y	X 或 Y
(X)	X，作为捕获组

字符类运算符的优先级如下所示，按从最高到最低的顺序排列：

1	字面值转义	/x
2	分组	[...]
3	范围	a-z
4	并集	[a-e][i-u]
5	交集	[a-z&&[aeiou]]

含义：用来描述或者匹配一系列符合某个语句规则的字符串

案例1：把一个字符串中带电话号码替换成1301111

String str = "小红13012341111，小绿15112342222";
String regex = "(1\\d{2})(\\d{4})(\\d{4})";
str = str.replaceAll(regex, "$1****$3");
System.out.println(str);

案例2：校验QQ邮箱

String str = "1445584980@qq.com";
String regex = "\\d{5,11}@qq\\.com";
//判断正则表达式是否匹配该字符串
boolean matches = str.matches(regex);
//底层实现
//boolean matches = Pattern.matches(regex , str);
System.out.println(matches);

案例3：分隔路径

String str = "C:\\资源\\日韩\\波多野结衣.avi";
String regex = ":?\\\\"; 
String[] split = str.split(regex);//依据正则表达式分隔字符串

//底层实现
Pattern pattern = Pattern.compile(regex);//创建匹配模式对象 -- Pattern正则表达式对象
String[] split = pattern.split(str);

for (String s : split) {
System.out.println(s);
}

案例4：Pattern+Matcher 找到前端代码中的图片路径

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|\\.bmp|\\.eps|\\.gif|\\.mif|\\.miff|\\.png|\\.tif|\\.tiff|\\.svg|\\.wmf|\\.jpe|\\.jpeg|\\.dib|\\.ico|\\.tga|\\.cut|\\.pic)\\b)[^>]*>";

Pattern pattern = Pattern.compile(regex);//创建匹配模式对象

Matcher matcher = pattern.matcher(str);//获取匹配结果对象

System.out.println("在字符串中是否整个匹配：" + matcher.matches());
System.out.println("在字符串中是否开头就匹配：" + matcher.lookingAt());
System.out.println("在字符串中是否有包含匹配：" + matcher.find());


//      循环遍历匹配结果
//		while(matcher.find()){
//			System.out.println(matcher.group(2)); //matcher.group(2)-->获取正则表达式里第二个括号(组)里的内容
//			System.out.print("start:"+matcher.start()); //匹配的数据在字符串中开始的下标（包含）
//			System.out.println(" end:"+matcher.end()); //匹配的数据在字符串中结束的下标(不包含)
//		}		

二、日期类

1、Date：日期类

​ java.util.Date类表示特定的瞬间，精确到毫秒

Date date1 = new Date();
//星期   月份  日     时:分:秒	  时区	   年份
//Thu Jan 21 10:41:31 CST 2021
System.out.println(date1);

//自1970年1月1日0:0:0 往后退1000毫秒
Date date2 = new Date(1000);
System.out.println(date2);

2、SimpleDateFormat：格式化日期类

//创建格式化日期类的对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

//将Date对象 格式化 字符串
String format = sdf.format(new Date());
System.out.println(format);

//将字符串 解析成 Date对象
Date date = sdf.parse("2021年01月21日 10:61:57");
System.out.println(date);

3、Calendar：日历类

//获取日历类的对象
Calendar c = Calendar.getInstance();

//获取对应的数据
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+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);

三、Math类

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

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

Math的常用方法

System.out.println("求平法：" + Math.pow(3, 2));
System.out.println("求平法根：" + Math.sqrt(9));
System.out.println("求绝对值：" + Math.abs(-100));
System.out.println("向下取整：（地板）" + Math.floor(1.9));
System.out.println("向上取整：（天花板）" + Math.ceil(1.1));
System.out.println("最大值：" + Math.max(10, 20));
System.out.println("最小值：" + Math.min(10, 20));
System.out.println("四舍五入：" + Math.round(1.4));
System.out.println("获取随机数（0包含~1不包含）：" + Math.random());

获取 1~100的随机数

System.out.println("获取随机数（1~100）：" + ((int)(Math.random()*100)+1));

面试题：abs可能出现负数吗？

//  可以  超出int区间
System.out.println(Math.abs(Integer.MAX_VALUE+1));

静态导入 缺点：可读性不高

//静态导入：将Math类中所有的静态属性和静态方法都认为是本类的
import static java.lang.Math.*;

public class Test04 {
	
	public static void main(String[] args) {
		System.out.println(max(10, 20));
		//  就近原则
		System.out.println(min(10, 20));
	}
	
	public static int min(int a,int b){
		return 100;
	}

}

四、 Random类

此类用于生成随机数：

Random(); 创建一个新的随机数生成器

Random(long seed);种子数(重点理解工作原理，什么是伪随机数)

常用方法

//创建随机类的对象
Random ran = new Random();
// int范围内
System.out.println("随机出int数字：" + ran.nextInt());
System.out.println("随机出int数字：" + ran.nextInt(10));//随机出0包含~10不包含
System.out.println("随机出double数字：" + ran.nextDouble());
System.out.println("随机出boolean数据：" + ran.nextBoolean());

案例 点名器

String[] names = {"杨晨","陈希","邓静涵","王永琪"};

Random ran = new Random();

int index = ran.nextInt(names.length);

System.out.println(names[index]);

理解随机类的种子数 种子数固定，随机出的值也是固定的

Random ran = new Random(1000);
System.out.println(ran.nextInt(10));

MyRandom myRandom = new MyRandom(1000);
System.out.println(myRandom.nextInt(10));

public class MyRandom {
	private long seed;//种子数
	public MyRandom() {
		this(seedUniquifier() ^ System.nanoTime());
	}
	private static long seedUniquifier() {
        for (;;) {
            long current = 100;
            long next = current * 3;
            if (next%5 == 0 || next % 21 == 0 || next % 28 == 0)
                return next;
        }
    }

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

五、System类

Java程序的运行平台

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

staticPrintStream	err “标准”错误输出流。
staticInputStream	in “标准”输入流。
staticPrintStream	out “标准”输出流。

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

//获取系统标准的输入流（方向：控制台->程序）
InputStream in = System.in;

Scanner scan = new Scanner(in);
String str = scan.next();
scan.close();

//打印流（系统标准的输出流）(方向：程序->控制台)
//		PrintStream out = System.out;
//		out.println(str);

//打印流（系统标准的错误输出流）(方向：程序->控制台)
PrintStream err = System.err;
err.println(str);

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

//退出当前虚拟机
System.exit(0);

//获取系统参数
Properties properties = System.getProperties();
System.out.println(properties);

//获取指定键上的值
String value = System.getProperty("os.name","默认值");
System.out.println(value);

研究System.out 和 System.err

System.out.println("小明");
System.err.println("小红");
System.out.println("小强");

结论：
System.out 和 System.err 是两个线程，哪个线程抢到CPU资源
哪个线程就运行，所以多线程的程序随机性很强

六、Runtime

Runtime代表Java程序的运行时环境，可以通过 getRuntime 方法获取当前运行时。

应用程序不能自己创建Runtime对象，可以通过Runtime的静态方法getRuntime()获得Runtime对象。

Runtime类可以访问jvm的相关信息，如处理器数量，内存信息等

//获取到运行环境类
Runtime run = Runtime.getRuntime();

System.out.println("获取最大内存量（字节）：" + run.maxMemory());
System.out.println("获取闲置内存量（字节）：" + run.freeMemory());
System.out.println("获取处理数：" + run.availableProcessors());

理解频繁的字符串拼接使用StringBuilder或StringBuffer

Runtime run = Runtime.getRuntime();

long startTime = System.currentTimeMillis();
long startMemory = run.freeMemory();

StringBuilder sb = new StringBuilder("邓静涵");
for (int i = 0; i < 20000; i++) {
	sb.append("我的小可爱，皇冠给你带");
}

long endMemory = run.freeMemory();
long endTime = System.currentTimeMillis();

System.out.println("消耗时长：" + (endTime - startTime));
System.out.println("消耗内存：" + (startMemory - endMemory));

消耗内存可能负数的情况吗？

​ 有可能，因为java的垃圾回收器会时时监听有没有没用的对象或变量，如果及时回收了，那么endMemory有可能比startMemory还更大

七、 BigInteger类和BigDecemal

BigInteger: 能表示比Integer更大的数字

BigInteger big1 = new BigInteger("20000000000000000000000000000000");
BigInteger big2 = new BigInteger("10000000000000000000000000000000");

System.out.println("加法：" + big1.add(big2));
System.out.println("减法：" + big1.subtract(big2));
System.out.println("乘法：" + big1.multiply(big2));
System.out.println("除法：" + big1.divide(big2));

BigDecimal：浮点数的计算

BigDecimal big1 = new BigDecimal("0.5");
BigDecimal big2 = new BigDecimal("0.4");

System.out.println("加法：" + big1.add(big2));
System.out.println("减法：" + big1.subtract(big2));
System.out.println("乘法：" + big1.multiply(big2));
System.out.println("除法：" + big1.divide(big2));

小数类型的大数值运算

BigDecimal big1 = new BigDecimal("10");
BigDecimal big2 = new BigDecimal("3");

System.out.println("除法：" + big1.divide(big2, 2, BigDecimal.ROUND_HALF_UP));

理解BigInteger

MyBigInteger big1 = new MyBigInteger("500000050");
MyBigInteger big2 = new MyBigInteger("500000050");

System.out.println("加法：" + big1.add(big2));

public class MyBigInteger {
	
	private String value;

	public MyBigInteger(String value) {
		this.value = value;
	}
	
	public MyBigInteger add(MyBigInteger big){
		//转换为字符数组
		char[] v1 = this.value.toCharArray();
		char[] v2 = big.value.toCharArray();
		//获取最后的下标
		int index1 = v1.length-1;
		int index2 = v2.length-1;
		int num = 0;//进位
		StringBuilder sb = new StringBuilder();
		while(index1 >= 0 || index2 >= 0){
			int num1 = 0;
			int num2 = 0;
			if(index1 >= 0){
				num1 = Integer.parseInt(String.valueOf(v1[index1]));
			}
			if(index2 >= 0){
				num2 = Integer.parseInt(String.valueOf(v2[index2]));
			}
			int result = num1 + num2 + num;
			if(result >= 10){
				num = 1;
				result = result%10;
			}else{
				num = 0;
			}
			index1--;
			index2--;
			sb.append(result);
		}
		
		if(num == 1){
			sb.append(1);
		}
		sb.reverse();//反转
		return new MyBigInteger(sb.toString());
	}

	@Override
	public String toString() {
		return value;
	}
}