admin管理员组文章数量:1579369
文章目录
- 一、正则表达式
- 二、日期类
- 三、Math类
- 四、 Random类
- 五、System类
- 六、Runtime
- 七、 BigInteger类和BigDecemal
一、正则表达式
正则表达式常用文档
字符 | |
---|---|
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";
String regex = "\\d{5,11}@qq\\";
//判断正则表达式是否匹配该字符串
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类提供了一些静态属性和方法,允许通过类名直接调用。
static PrintStream | err “标准”错误输出流。 |
---|---|
static InputStream | in “标准”输入流。 |
static PrintStream | 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;
}
}
版权声明:本文标题:JavaEE基础知识 内容由热心网友自发贡献,该文观点仅代表作者本人, 转载请联系作者并注明出处:https://m.elefans.com/xitong/1727847895a1133309.html, 本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,一经查实,本站将立刻删除。
发表评论