Java常用API讲解
文章目录
一、Math类
java.lang.Math类
| 方法名 | 说明 |
|---|---|
| public static int abs() | 绝对值 |
| public static double ceil() | 向上取整 |
| public static double floor() | 向下取整 |
| public static int round() | 四舍五入 |
| public static int max(int a, int b) | 获取两个值中的大值 |
| public static int min(int a, int b) | 获取两个值中的小值 |
| public static double pow(double a, double b) | 返回a的b次幂 |
| public static double random() | 返回值为double的随机值，范围[0.0, 1.0]。 |
| sqrt() | 开平方 |
| cbrt() | 开立方 |
abs()方法
取绝对值，但是有bug，数值最小值的绝对值取不到，会返回错误数据。
说明：以int类型为例，取值范围：-2147483648 ~ 2147483647
最小值-2147483648没有正数与之对应，所以abs结果产生bug。当数值足够小，可能产生错误时，考虑使用Math.absExact()方法。
random()方法
用random取得随机数，例如取1-100的随机数：Math.floor(Math.random() * 100) + 1。
二、System类
System也是一个工具类，提供了一些与系统相关的方法。
| 方法名 | 说明 |
|---|---|
| public static void exit(int status) | 终止当前运行的Java虚拟机 |
| public static long currentTimeMillis() | 返回当前系统的时间毫米值形式，离1970年1月1日 00:00:00的毫秒数，我国位于东八区，获取到的时间原点为1970年1月1日 08:00:00 |
| public static void arraycopy(源数组，起始索引，目的数组，起始索引，拷贝个数) | 数据拷贝 |
arraycopy()方法
细节：
- 如果数据源数组和目的地数组是基本类型，那么两者的类型必须保持一致，否则会报错
- 在拷贝的时候需要考虑数组的长度，如果超出范围也会报错
- 如果数据源数组和目的地数组都是引用类型，那么子类类型可以复制给父类类型
三、Runtime类
获取Runtime对象
使用Runtime getRuntime()方法获取对象
常用方法
| 方法名 | 说明 |
|---|---|
| public static Runtime getRuntime() | 当前系统的运行环境对象 |
| public void exit(int status) | 停止虚拟机 |
| public int availableProcessors() | 获取CPU的线程数 |
| public long maxMemory() | JVM能从系统中获取总内存大小（单位byte） |
| public long totalMemory() | JVM已经从系统中获取总内存大小（单位byte) |
| public long freeMemory() | JVM剩余内存大小（单位byte） |
| public Process exec(String command) | 运行cmd命令 |
四、Object类
Object是Java中的顶级父类。所有的类都直接或间接的继承于Object类。
| 方法名 | 说明 |
|---|---|
| public Object() | 空参构造 |
| public String toString() | 返回对象的字符串表示形式 |
| public boolean equals(Object obj) | 比较两个对象是否相等 |
| protected Object clone(int a) | 对象克隆 |
toString()方法
如果我们需要打印一个对象看到他的属性值的话，那么就要重写toString方法即可。在重写时把属性拼接进去。
equals()方法
-
如果没有重写equals方法，那么默认使用Object中的方法进行比较，比较的是地址值是否相等
-
一般来讲地址值对于我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值了。
重写后的equals()方法就是比较对象的属性值。
clone()方法
把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。Object中的克隆是浅克隆。
标记性接口(如Cloneable)
-
如果一个接口里面没有抽象方法
-
表示当前的接口是一个标记性接口
-
现在Cloneable表示一旦实现，那么当前类的对象就可以被克隆
-
如果没有实现，当前类的对象就不能克隆
克隆的2种方式
- 浅克隆 不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来
- 深克隆 基本数据类型拷贝过来；字符串复用；引用数据类型会重新创建新的（深克隆需要重写clone方法或使用第三方工具类）
使用第三方工具深克隆（应用GSON包）
- 第三方工具包导入项目中，在项目中添加lib文件夹，将jar包拷贝到lib中
- 右击jar包，点击 添加为库 后即可使用
User u1 = new User(1, "刘爽", "123456", "girl1", new int[]{1,2,3,4,5});
// 创建GSON对象
Gson gson = new Gson();
// 通过GSON对象将对象转换为JSON字符串
String s = gson.toJson(u1);
// 打印JSON对象
System.out.println(s);
// 再把JSON字符串还原为对象
User u2 = gson.fromJson(s, User.class);
// 打印对象
System.out.println(u2);
// -----------------------
// 输出为：
// {"id":1,"username":"刘爽","password":"123456","path":"girl1","data":[1,2,3,4,5]}
// User{id=1, username='刘爽', password='123456', path='girl1', data=[1, 2, 3, 4, 5]}
五、Objects工具类
Objects是一个工具类，提供了一些方法去完成一些功能。
| 方法名 | 说明 |
|---|---|
| public static boolean equals(Object a, Object b) | 先做非空判断，比较两个对象 |
| public static boolean isNull(Object obj) | 判断对象是否为null，为null返回true，反之亦然 |
| public static boolean nonNull(Object obj) | 判断对象是否为null，跟isNull的结果相反 |
六、BigInteger类
在Java中，整数有四种类型：byte,short,int,long。
在底层占用字节个数：byte 1个字节、short 2个字节、int 4个字节、long 8个字节。
BigInteger构造方法
| 方法名 | 说明 |
|---|---|
| public BigInteger(int num, Random rnd) | 获取随机大整数，范围：[0 ~ 2的num次方-1] |
| public BigInteger(String val) | 获取指定的大整数 |
| public BigInteger(String val, int radix) | 获取指定进制的大整数 |
| public static BigInteger valueOf(long val) | 静态方法获取BigInteger的对象，内部有优化（1. 表示的范围比较小，只有long的范围；2.对内部常用的数字-16 ~ 16进行了优化，提前把-16~16创建好BigInteger对象，如果多次获取不会重新创建新的） |
对象一旦创建，内部记录的值不能发生改变。
BigInteger构造方法小结
-
如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
-
如果BigInteger表示的超出long的范围可以用构造方法获取。
-
对象一旦创建，BigInteger内部记录的值不能发生改变
-
只要进行计算都会产生一个新的BigInteger对象
BigInteger成员方法
| 方法名 | 说明 |
|---|---|
| public BigInteger add(BigInteger val) | 加法 |
| public BigInteger subtract(BigInteger val) | 减法 |
| public BigInteger multiply(BigInteger val) | 乘法 |
| public BigInteger divide(BigInteger val) | 除法，获取商 |
| public BigInteger[] divideAndRemainder() | 除法，获取商和余数 |
| public boolean equals(Object x) | 比较是否相同 |
| public BigInteger pow(int exponent) | 次幂 |
| public BigInteger max/min(BigInteger val) | 返回较大值/较小值 |
| public int intValue(BigInteger val) | 转为int类型整数，超出范围时数据有误 |
BigInteger底层存储方式
七、BigDecimal类
作用：1.用于小数的精确计算；2.用来表示很大的小数
| 类型 | 占用字节数 | 总bit位数 | 小数部分bit位数 |
|---|---|---|---|
| float | 4个字节 | 32个bit位 | 23个bit位 |
| double | 8个字节 | 64个bit位 | 52个bit位 |
构造方法
BigDecimal(double)具有不可预知性，不建议使用；应使用BigDeciaml(String)构造方法，精确。
细节
-
如果要表示的数字不大，没有超出double的取值范围，建议使用静态方法
-
如果要表示的数字比较大，超出了double的取值范围，建议使用构造方法
-
如果我们传递的是0~10之间的整数，包含0,包含10,那么方法会返回已经创建好的对象，不会重新new
常用方法
| 方法名 | 说明 |
|---|---|
| public static BigDecimal valueOf(double val) | 获取对象 |
| public BigDecimal add(BigDecimal val) | 加法 |
| public BigDecimal subtract(BigDecimal val) | 减法 |
| public BigDecimal multiply(BigDecimal val) | 乘法 |
| public BigDecimal divide(BigDecimal val) | 除法 |
| public BigDecimal divide(BigDecimal val, 精确几位, 舍入模式) | 除法 |
八、正则表达式
（一）正则表达式的作用
作用一：校验字符串是否满足规则
作用二：在一段文本中查找满足要求的内容
（二）正则表达式
1.字符类（只匹配一个字符）
| 表达式 | 说明 |
|---|---|
| [abc] | 只能是a,b,或c |
| [ ^ abc] | 除了a,b,c之外的任何字符 |
| [a-zA-Z] | a到zA到Z,包括(范围) |
| [a-d[m-p]] | a到d,或m到p |
| [a-z&&[def]] | a-z和def的交集。为：d,e,f |
| [a-z&&[ ^bc]] | a-z和非bc的交集。(等同于[ad-z]) |
| [a-z&&[ ^m-p]] | a到z和除了m到p的交集。(等同于[a-lq-z]) |
如果要求两个范围的交集，使用&&（两个&&），如果写成了一个&，那么仅表示&符号本身。
2.预定义字符（只匹配一个字符）
| 表达式 | 说明 |
|---|---|
| . | 任意字符 |
| \d | 一个数字：[0-9] |
| \D | 非数字：[ ^0-9] |
| \s | 一个空白字符：[\t\n\x0B\f\r] |
| \S | 非空白字符：[ ^\s] |
| \w | [a-zA-Z_0-9]英文、数字、下划线 |
| \W | [ ^\w]一个非单词字符 |
3.数量限定字符
| 表达式 | 说明 |
|---|---|
| X? | X，1次或0次 |
| X* | X，0次或多次 |
| X+ | X，1次或多次 |
| X{n} | X，正好n次 |
| X{n,} | X，至少n次 |
| X{n,m} | X，至少n次但不超过m次 |
注：X表示正则中任意表意单元
4.其他正则表达字符
| 表达式 | 说明 |
|---|---|
| (?i)X | 表示对小括号后的X忽略大小写 |
5.java.util.regex.Pattern类
该类API文档中，有详细的正则表达式规则说明。
6.分组，使用小括号
// 为了匹配.com结尾或类似.com.cn结尾的地址(\\.[a-zA-Z]{2,3}){1,2}，分组可以出现1-2次
String emailRegex = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}"
7.IDEA正则插件any-rule
安装成功后，右键定义的字符串，右键 - AnyRule - 选择需要的正则表达式即可。
String regex = ""; // 在双引号中右击，选择AnyRule
// 选择合适的规则后，插件会自动填充regex
8.正则表达式小结
| 符号 | 含义 | 举例 |
|---|---|---|
| [] | 里面的内容出现一次 | [0-9] [a-zA-Z0-9] |
| () | 分组 | a(bc)+ |
| ^ | 取反 | [^abc] |
| && | 交集，不能写单个的& | [a-z&&m-p] |
| | | 写在方括号外面表示并集 | [a-zA-Z0-9] x|X |
| . | 任意字符 | \n 回车符不匹配 |
| \\ | 转义字符 | \\d |
| \\d | 0-9 | \\d+ |
| \\D | 非0-9 | \\D+ |
| \\s | 空白字符 | [\t\n\x0B\f\r] |
| \\S | 非空白字符 | [^\s] |
| \\w | 单词字符 | [a-zA-Z_0-9] |
| \\W | 非单词字符 | [^\w] |
| ? | 0次或1次 | \\d? |
| * | 0次或多次 | \\d* (abc)* |
| + | 1次或多次 | \\d+ （abc)+ |
| {} | 具体次数 | a{7} \\d{7,19} |
| (?i) | 忽略后面字符的大小写 | (?i)abc |
| a((?i)b)c | 只忽略b的大小写 | a((?i)b)c |
（三）爬取数据
1. Matcher和Pattern类
java.util.regex.Matcher
java.util.regex.Pattern
-
Pattern: 表示正则表达式
-
Matcher：文本匹配器，按照正则表达式的规则去读取字符串，从头开始读取。从大串中去找符合规则的小串。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RDemo5 {
public static void main(String[] args) {
// 待查找的文本
String str = "Java来讲ogai啦蓝黄横在坑eoi领我到坏藏elgz在灵界蓝噶皇宫赛风Java8龙扽噶Java11，" +
"垃圾噶完成常人给怀旧后尔城河东看僧李娟含含肯白Java17，蓝哈根后汉肯定Java17看僧房oejh。";
// 获取正则表达式对象
Pattern p = Pattern.compile("Java\\d{0,2}"); // 方法参数位正则表达式
// 获取文本匹配器的对象
// m: 文本匹配器的对象
// str: 大串
// p: 规则
// m要在str中找符合p规则的小串
Matcher m = p.matcher(str);
/*
// 拿着文本匹配器从头开始读取，寻找是否有满足规则的子串
// 如果没有，方法返回false
// 如果有，返回true。在底层记录子串的起始索引和结束索引+1
boolean b = m.find();
// 方法底层会根据find()方法记录的索引进行字符串的截取
// subString(起始索引,结束索引); 包头不包尾
*/
// 循环取出所有匹配的项
while (m.find()){
System.out.println(m.group());
}
}
}
示例2，获取多组规则匹配的文本：
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RDemo8 {
public static void main(String[] args) {
/*
需求:把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。
来黑马程序员学习Java，
手机号:18512516758，18512508907或者联系邮箱:boniu@itcast.cn，
座机电话:01036517895，010-98951256邮箱:bozai@itcast.cn，
热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090
手机号的正则表达式:1[3-9]\d{9}
邮箱的正则表达式:\w+@[\w&&[^_]]{2,6}(\.[a-zA-Z]{2,3}){1,2}座机电话的正则表达式:θ\d{2,3}-?[1-9]\d{4,9}
热线电话的正则表达式:400-?[1-9]\\d{2}-?[1-9]\\d{3}
*/
String s = "来黑马程序员学习Java，" +
"电话:18512516758，18512508907" + "或者联系邮箱:boniu@itcast.cn，" +
"座机电话:01036517895，010-98951256" + "邮箱:bozai@itcast.cn，" +
"热线电话:400-618-9090 ，400-618-4000，4006184000，4006189090";
// System.out.println("400-618-9090");
String regex = "(1[3-9]\\d{9})|(\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2})" +
"|(0\\d{2,3}-?[1-9]\\d{4,9})" +
"|(400-?[1-9]\\d{2}-?[1-9]\\d{3})";
// 1.获取正则表达式对象
Pattern p = Pattern.compile(regex);
// 2. 文本匹配器对象
Matcher m = p.matcher(s);
// 3. 获取匹配的对象
while(m.find()){
String str = m.group();
System.out.println(str);
}
}
}
/* 输出为：
18512516758
18512508907
boniu@itcast.cn
01036517895
010-98951256
bozai@itcast.cn
400-618-9090
400-618-4000
4006184000
4006189090
*/
2. 有条件爬取
//1: 匹配Java8、Java11、Java17中的java字符（java忽略大小写）
String regex1 = "((?i)Java)(?=8|11|17)";
//2: 匹配Java8、Java11、Java17字符（java忽略大小写）
String regex2 = "((?i)Java)(8|11|17)";
String regex3 = "((?i)Java)(?:8|11|17)";
//3: 不匹配Java8、Java11、Java17中的java字符（java忽略大小写）
String regex4 = "((?i)Java)(?!8|11|17)";
（四）替换
| 方法名 | 说明 |
|---|---|
| public String[] matches(String regex) | 判断字符串是否满足正则表达式的规则 |
| public String replaceAll(String regex, String newStr) | 按照正则表达式的规则进行替换 |
| public String[] split(String regex) | 按照正则表达式规则切割字符串 |
（五）分组
从左往右数，从1开始数，数左括号的数量，第几个左括号就是第几组。
- 捕获分组
后续还要继续使用本组的数据
- 正则内部使用：\\组号
- 正则外部使用：$组号
public static void main(String[] args) {
//需求1:判断一个字符串的开始字符和结束字符是否一致?只考虑一个字符
//举例: a123a b456b 17891 &abc& a123b(false)
// \\组号:表示把第X组的内容再出来用一次
String regex1 = "(.).+\\1";
System.out.println("a123a".matches(regex1));
System.out.println("b456b".matches(regex1));
System.out.println("17891".matches(regex1));
System.out.println("&abc&".matches(regex1));
System.out.println("a123b".matches(regex1));
System.out.println("--------------------------");
//需求2:判断一个字符串的开始部分和结束部分是否一致?可以有多个字符
//举例: abc123abc b456b 123789123 &!@abc&!@ abc123abd(false)
String regex2 = "(.+).+\\1";
System.out.println("abc123abc".matches(regex2));
System.out.println("b456b".matches(regex2));
System.out.println("123789123".matches(regex2));
System.out.println("&!@abc&!@".matches(regex2));
System.out.println("abc123abd".matches(regex2));
System.out.println("---------------------");
//需求3:判断一个字符串的开始部分和结束部分是否一致?开始部分内部每个字符也需要一致
//举例: aaa123aaa bbb456bbb 111789111 &&abc&&
//(.):把首字母看做一组
// \\2:把首字母拿出来再次使用
// *:作用于\\2,表示后面重复的内容出现日次或多次
String regex3 = "((.)\\2*).+\\1";
System.out.println("aaa123aaa".matches(regex3));
System.out.println("bbb456bbb".matches(regex3));
System.out.println("111789111".matches(regex3));
System.out.println("&&abc&&".matches(regex3));
System.out.println("aaa123aab".matches(regex3));
}
正则外部使用：$组号
public static void main(String[] args) {
/*String s = "唐僧jlsagfsg2as33孙悟空lasgs35kdh2398猪八戒";
String result = s.replaceAll("([\\w&&[^_]]+)", "&");
System.out.println(result);*/
String str = "我要学学编编编编编编程程程程程程";
String pattern = "(.)\\1+";
String result = str.replaceAll(pattern, "$1"); //这里的$1即表示分组(.)
System.out.println(result);
}
- **非捕获分组 **
分组之后不需要再用本组数据，仅仅是把数据括起来。不占用组号。
| 符号 | 含义 | 举例 |
|---|---|---|
| (?:正则) | 获取所有 | Java(?:8|11|17) |
| (?=正则) | 获取前面部分 | Java(?=8|11|17) |
| (?!正则) | 获取不是指定内容的前面部分 | Java(?!8|11|17) |
- 小结
（1).正则表达式中分组有两种：捕获分组、非捕获分组
(2).捕获分组(默认):
可以获取每组中的内容反复使用。
(3).组号的特点：
从1开始，连续不间断以左括号为基准，最左边的是第一组
(4).非捕获分组：
分组之后不需要再用本组数据，仅仅把数据括起来，不占组号。(?😃(?=)(?!)都是非捕获分组
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
