JavaSe(11) - 常用API(上)
P155 Math
基本数学计算的工具类,包含执行基本数学运算的方法, 例如指数, 对数, 平方根, 三角函数...
| 方法名 | 说明 |
|---|---|
| public static int abs(int a) | 获取绝对值 |
| ceil(double a) | 向上取整 |
| floor(double a) | 向下取整 |
| round(float a) | 四舍五入 |
| max(int a,int b) | 获取较大值 |
| pow(double a,double b) | a的n次幂 |
| sqrt / cbrt(double a) | 平方根 / 立方根 |
| random() | [0.0 , 1.0)的随机数 |
//abs()绝对值
System.out.println(Math.abs(-12));//12
//ceil(double a)向上取整
System.out.println(Math.ceil(-5.9));//-5.0
//floor(double a)向下取整
System.out.println(Math.floor(-5.9));//-6.0
System.out.println("----------------");
//round(float a)四舍五入
System.out.println(Math.round(-5.53));//-6
//max(int a,int b)获取较大值
System.out.println(Math.max(1, 2));//2
//pow(double a,double b)a的n次幂, 建议第二个参数传递大于等于1的正整数.
System.out.println(Math.pow(2, 3));//2的3次方是8.0
System.out.println(Math.pow(16, 0.25));//16的4次方根(1/4)是2.0
System.out.println(Math.pow(2, -2));//2的-2次方是0.25.
//sqrt/cbrt(),开平/立方根的方法
System.out.println(Math.sqrt(4));//4的开平方根是2.0
System.out.println(Math.cbrt(8));//8的立方根是2.0
P 156 Math练习题
- 判断一个数是否为质数, 循环到此数的平方根就可以结束,来提高效率.
- 自幂数, 一个n位自然数等于自身各个位数上数字的n次方之和.
一位自幂数叫独身数, 三位自幂数叫水仙花数, 4位数叫四叶玫瑰数,5位叫五角星数.....
- 统计一共有多少个水仙花数 . 证明没有两位自幂数. 分别统计有多少个四叶玫瑰数和五角星数.
P 157 System
- System : 也是一个工具类, 提供了一些与系统相关的方法.
- 时间原点 : 1970年1月1日 0:0:0 , 我国在东八区, 晚8小时.
- 常见方法如下:
public static void exit(int status): 终止当前运行的Java虚拟机
public static long currentTimeMillis(): 返回当前系统的时间
public static void arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引,拷贝个数 ):拷贝数组
- 如果数据源数组和目的地数组都是基本数据类型, 那么两者的数据类型必须一致.
- 在拷贝时需要考虑数组长度以免数组越界.
- 如果数据源数组和目的地数组都是引用数据类型,那么子类类型可以赋值给父类类型.
P 158 Runtime
当前虚拟机的运行环境
public static Runtime getRuntime() 当前系统的运行环境对象
public void exit(int status) 停止虚拟机
public int availableProcessors() 获得CPU的线程数
public long maxMemoryO JVM能从系统中获取总内存大小（单位byte)
public long totalMemory() JVM已经从系统中获取总内存大小（单位byte)
public long freeMemory() JVM剩余内存大小（单位byte)
public Process exec(String command) 运行cmd命令
不能自己new对象, 只能调用Runtime.getRuntime(); 创建对象
练习题 : 利用Runtime中的方法, 来恶搞好基友.
创建窗口,有三个按钮, 按错了就给他惩罚--给他的电脑关机. 如果求饶就取消关机.
P 159 Object
toString 方法 :
默认情况下, 因为Object类中的toString方法返回地址值, 但我们要看的是属性值. 所以要重写父类Object类中的toString方法, 在重写时,把对象的属性值进行拼接.
equals 方法 :
如果没有重写equals方法, 那么默认使用Object中的方法进行比较, 比较的是地址值是否相等. 一般来说地址值对我们意义不大,*** 所以我们会重写, 重写之后就是比较对象内部的属性值了.**
P 160 clone
练习题 :
创建一个JavaBean类User, int id,String username用户名,String password 密码,String path图片,int[]data 进度, 再重写toString方法, 和arrToString方法,用StringJoiner(,[])拼接数组返回字符串.
- 创建对象
- 克隆对象 : 在User类中重写父类的clone方法, 还要让Javabean类实现Cloneable标记接口. 如果一个接口里面没有抽象方法, 表示当前的接口是一个标记接口, 现在Cloneable 表示一旦实现了, 那么当前类的对象就可以被克隆, 如果没有实现, 当前类的对象就不能克隆.
- 克隆时要从Obje类型强转为User类型对象
Java中的 clone方法是浅克隆.
-
浅克隆 : 不管大小内部的属性是基本数据类型还是引用数据类型, 都完全拷贝过来
-
深克隆 : 基本数据类型拷贝过来, 字符串复用, 引用数据类型会重新创建新的.
-
验证Object类中的clone方法是否是浅克隆.
-
我们要把对象深克隆就要在Javabean类中重写clone方法 ,1,把被克隆的数组获取出来, 2,创建新的数组 3,拷贝数组中的数据 4, 调用父类中的clone方法克隆对象 5, 因为父类中的克隆方法是浅克隆, 要把我们创建的数组替换为方法克隆的数组.
-
利用第三方工具实现深克隆 : 1,第三方代码导入项目中 2,编写代码Gson gson = new Gson(); 3,把对象变成一个字符串 String s = gson.toJson(u1); 3,再把字符串变回对象 User user = gson.fromJson(s, User.class);
总结:
- Object是Java中的顶级父类. 所有的类都直接或间接继承于Object类
- toString() : 一般会重写, 打印对象时打印属性
- equals() : 比较对象时会重写, 比较对象属性值是否相同
- clone() : 默认浅克隆. 如果需要深克隆要重写方法或使用第三方工具类.
Objects工具类
常用方法:
equals(Object a,Object b) : 先做非空判断, 比较两个对象
isNull(Object obj) : 判断对象是否为空, null返回true
nonNull(Object obj) : 判断对象是否为空, null返回false
P 161 BigInteger , BigDecimal(大整数,大小数)
BigInteger构造方法
public BigInteger(int num,Random rnd) 获取随机大整数,范围:[0~2的num次方-1]
public BigInteger(String val) 获取指定大整数
public BigInteger(String val,int radix) 获取指定进制大整数
...static BigInteger valueOf(long val) 静态方法获取BigInteger对象, 内部有优化
注意 : 对象一旦创建, 内部记录的值不能发生变化
总结 :
- 如果数字没有超出long的范围, 可以用静态方法获取.
- 如果数字超出了long的范围, 可以用构造方法获取.
- 对象一旦创建, 内部记录的值不能发生变化.
- 只要进行计算都会产生一个新的BigInteger对象.
BigInteger常见方法
BigInteger b1 = BigInteger.valueOf(5);
BigInteger b2 = BigInteger.valueOf(10);
//加法
BigInteger add = b1.add(b2);
System.out.println(add);//15
//减法
System.out.println(b1.subtract(b2));//-5
//乘法
System.out.println(b1.multiply(b2));//50
//除法
System.out.println(b1.divide(b2));//0
//除法,获取商和余数
BigInteger[] bigIntegers = b1.divideAndRemainder(b2);
System.out.println(bigIntegers[0] + "," + bigIntegers[1]);//0,5
//比较是否相同
System.out.println(b1.equals(b2));//false
//次幂
System.out.println(b1.pow(2));//25
//返回较大/较小值
System.out.println(b1.max(b2));//10
//转换为int整数类型, 超出范围数据有误
System.out.println(b1.intValue());//5
System.out.println(b2.doubleValue());//10.0
BigInteger 总结
- BigInteger 表示一个大整数
- 如何获取BigInteger的对象
BigInteger b1 = BigInteger.valueOf(5);
BigInteger b2 = new BigInteger("5");
- 常见操作
加: add 减 : subtract 乘 : multiply 除 : divide / divideAndRemainder
比较 : equals / max / min 次幂 : pow 转成整数 : intValue / longValue /dou...
P162 BigDecimal(大小数)
- BigDecimal的作用 : 表示较大的小数和解决小数计算不精确的问题
- BigDecimal的对象如何获取 :
BigDecimal b1 = BigDecimal.valueOf(0.1);
BigDecimal b2 = new BigDecima("0.1");
- 常见操作 : 加减乘除 ( 除法的舍入模式 , 四舍五入, RoundingMode.HALF_UP )
BigDecimal b1 = BigDecimal.valueOf(0.1);
BigDecimal b2 = BigDecimal.valueOf(0.9);
BigDecimal b3 = BigDecimal.valueOf(3);
//add
System.out.println(b1.add(b2));//1.0
//subtract
System.out.println(b1.subtract(b2));//-0.8
//multiply
System.out.println(b1.multiply(b2));//0.09
//divide RoundingMode.HALF_UP四舍五入
System.out.println(b1.divide(b3, 4, RoundingMode.HALF_UP));//0.0333
P 163 正则表达式
字符类(只匹配一个字符)
[abc] 只能是a,b,c
[^abc] 除了abc之外的任何字符
[a-zA-Z] a到z A到Z,都包括
[a-d[m-p]] a到b,或m到p
[a-z&&[def]] a到z, def的交集 --def
[a-z&&[(^)bc]] a到z, 和非bc的交集 [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] 一个非单词字符
\ 反斜线 为转义字符 , 改变后面那个字符原本的含义.
练习:以字符串的形式打印一个双引号.
System.out.println("\"");
*** " 在Java中表示字符串的开头和结尾***
" / " 表示转义字符, 改变了后面那个双引号原本的含义, 把它变成了一个普普通通的双引号.
System.out.println("C:\\Users\\Baby\\IdeaProjects\\JavaBasic\\API\\lib\\gson-2.6.2.jar");
" \ \ " 前面的" \ " 是一个转义字符, 改变了后面 \ 原本的含义, 把它变成一个普普通通的\ .
简单来记 : 两个" \ "表示一个" \ "
数量词
X? X, 一次或0次
X* X, 0次或多次
X+ X, 一次或多次
X{n} X, 正好n次
X{n,} X, 至少n次
X{n,m} X, 至少n但不超过m次
API - 帮助文档的 Pattern类中, 就有正则表达式的规则, 或者在String类中找matches方法也能找到.
P 164 正则表达式-练习1:
编写正则表达式校验用户输入的手机号码.
编写正则表达式校验用户输入的邮箱号码.
编写正则表达式校验用户输入的座机号码.
验证手机号码 13112345678 13712345667 13945679027 139456790271
验证座机电话号码 020-2324242 02122442 027-42424 0712-3242434
验证由 P 筘号码 3232323@qq.com zhangsan@itcast.cnn dlei0009@163.com dlei0009@pci.com.cn
心得：
拿着一个正确的数据，从左到右依次去写。
13112345678
分成三部分：
第一部分：1表示手机号码只能以1开头
第二部分：[3-9]表示手机号码第二位只能是3-9之间的
第三部分：\\d{9}表示任意数字可以出现9次, 也只能出现9次.
String regex1 = "1[3-9]\\d{9}";
System.out.println("13112345678".matches(regex1));
P 165 正则表达式-练习2:
正则表达式练:需求
请编写正则表达式验证用户名是否满足要求。
要求：大小写字母，数字，下划线一共4-16位
请编写正则表达式验证身份证号码是否满足要求。
简单要求：18位，前17位任意数字，最后一位可以是数字可以是大写或小写的X
复杂要求：按照身份证号码的格式严格要求。
例如: String regex1 = "\w{4,16}";
System.out.println("abc123".matches(regex1));
1, 身份证号码简单校验:
18位, 前17位任意数字, 最后一位是数字或是Xx.
2, 忽略大小写: String regex2 = "(?i)abc";/"a((?i)b)c";
3, 身份证号码的严格校验
编写正则的小心得：
第一步：按照正确的数据进行拆分
第二步：找每一部分的规律，并编写正则表达式
第三步：把每一部分的正则则拼接在一起，就是最终的结果
书写的时候：从左到右去书写。
例如 : 410801 1993 02 28 457x
前面6位：省份，市区，派出所等信息, 第一位不能是0,后面5位是任意数字
年的前半段：18 19 20
年的后半段：任意数字出现两次
月份： 01 〜09 10 11 12
口期： 01〜31
后面四位：任意数字出现3次, 最后一位可以是数字也可以是大写X或者小写X
/*
符号 含义 举例
[] 里面的内容出现一次 [0-9] [a-zA-ZO-9]
() 分组 a(bc)+
^ 取反 [^ abc]
&& 交集，不能写单个的& [a-z&&m-p]
| 写在方括号外面表示并集 [a-zA-ZO-9] x|X
. 任意字符 \n 回车符号不匹配
\ 转义字符 \\d
\\d 0-9 \\d+
\\D 非0-9 \\D+
\\s 空白字符 [\t\n\xOB\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
*/
P166 爬虫
爬取本地信息
Pattern 类 : 表示正则表达式
Matcher 类 : 文本匹配器, 作用按照正则表达式的规则去读取字符串 , 从头开始读取. 在大串中找符合匹配规则的子串.
public class regex_2 {
public static void main(String[] args) {
String str = "ibigekib;ksjv893563l2javaki1ucowlp[]java8iuybnx.;'\\][-*%$&java17iubyq`l";
//定义规则,获取正则表达式的对象
Pattern p = Pattern.compile("java\\d{0,2}");
//获取一个文本匹配器的对象
//m 文本匹配器对象
//p 规则
//str 大串
//m 要在str这个大串中,去找符合p这个规则的小串
Matcher m = p.matcher(str);
//用循环获取
while (m.find()){ //如果m.find()返回false,就说明后面没有再没有符合条件的了.
String s = m.group(); //根据find方法记录的索引截取字符串
System.out.println(s);
}
//find方法 boolean b = m.find();
//拿着文本匹配器从头读取,寻找是否有满足规则的字串
//如果没有,返回false
//如果找到,返回true,并在底层记录子串的开始索引和结束索引+1
//group方法 String s = m.group();
//group方法会根据find方法记录的索引进行字符串的截取
}
}
练习1:
需求：把下面文本中的座机电话，邮箱，手机号，热线都爬取出来。
来黑马程序员学习]ava,
手机号：18512516758, 18512508907
或者联系邮箱：boniu@itcast. cn
座机电话：01036517895, 010-98951256
邮箱：bozai@itcast.cn，
热线电话：400-618-9090 , 400-618-4000，4006184000, 4006189090
手机号的正则表达式：1[3-9]\d{9}
邮箱的IE则表达式：\w+@[\w&&[A_」]{2,6}(. [a-zA-Z]{2,3}){1,2}
座机电话的正则表达式：0\d{2,3}-?[1-9]\d{4,9}
热线电话的IE则表达式：400-?[1-9]\d{2}-?[1-9]\d{3}
P167 带条件爬取, 贪婪爬取和识别正则的两个方法
爬虫练习2:
有如下文本，请按照要求爬取数据。
Java自从95年问世以来，经历了很多版本，目前企业中用的最多的是java8和javall，因为这两个是长 期支持版本，下一个长期支持版本是javal7,相信在未来不久javal7也会逐渐登上历史舞台
需求1:爬取版本号为8,11,17的Java文本，但是只要Java,不显示版本号。
需求2:爬取版本号为8J1,17的Java文本。正确爬取结果为：Java8 Java11 Java17 Java17
需求3:爬取除了版本号为8,11,17的Java文本
/*需求1:爬取版本号为8,11,17的Java文本，但是只要Java,不显示版本号。
需求2:爬取版本号为8J1,17的Java文本。正确爬取结果为：Java8 Java11 Java17 Java17
需求3:爬取除了版本号为8,11,17的Java文本*/
public class regex3 {
public static void main(String[] args) {
//字符串
String str = "java自从95年问世以来，经历了很多版本，目前企业中用的最多的是Java8和JAva11，因为这两个是长 期支持版本，\n" +
"下一个长期支持版本是JAVa17,相信在未来不久JAVA17也会逐渐登上历史舞台";
//正则表达式
String regex1 = "((?i)java)(?=8|11|17)";//=是不要后面的
String regex2 = "((?i)java)(?:8|11|17)";//:是要后面的
String regex3 = "((?i)java)(?!8|11|17)";//!排除后面的
//获取正则表达式对象
Pattern p = Pattern.compile(regex2);
//获得文本匹配器对象
Matcher m = p.matcher(str);
//循环获取
while (m.find()) {
String s = m.group();
System.out.println(s);
}
}
}
贪婪爬取和非贪婪爬取
贪婪爬取 : 在爬取数据的时候尽可能的多获取数据
非贪婪爬取 : 在爬取数据的时候尽可能的少获取数据
Java中, 默认就是贪婪爬取 , 如果我们在数量词 + * 的后面加上问号, 那么就是非贪婪
练习 :
有如下文本, 请按照要求爬取数据
java自从95年问世以来，abbbbbbbbbbbbaaaaaaaaaaaa 经历了很多版本，目前企业中用的最多的是Java8和JAva11，因为这两个是长 期支持版本，\n" +
"下一个长期支持版本是JAVa17,相信在未来不久JAVA17也会逐渐登上历史舞台
需求1 : 按照ab+的方式爬取ab, b尽可能多获取
需求2 : 按照ab+的方式爬取ab, b尽可能少获取
正则表达式在字符串方法中的使用
常用方法:
String [] matches(String regex) 判断字符串是否满足正则表达式的规则
Strint replaceAll(String regex, String newStr) 按照正则的规则进行替换
String [] split(String regex) 按照正则表达式的规则切割字符串
练习:
有一段字符串 : 小明ijga;slkerjflakiu87y934hjlka;\小红89vf8723uoitjhl['l.,,m;drg']小李
需求1 : 把字符串中三个姓名之间的字母替换为VS
需求2 : 把字符串中的三个姓名切割出来
在java中方法形参如果是"regex",那么这个方法一定识别正则表达式
P168 捕获分组和非捕获分组
每一组是有组号的, 也就是序号
规则1: 从1开始, 连续不断
规则2: 以左括号为基准, 最左边的是第一组, 其次为第二组, 以此类推.
捕获分组就是把这一组的数据捕获出来，再用一次。
练习:
需求1:判断一个字符串的开始字符和结束字符是否一致？只考虑一个字符
举例：al 23a b456b 17891 &abc&
需求2:判断一个字符串的开始部分和结束部分是否一致？可以有多个字符
举例：abcl 23abc b456b 123789123 &!@abc&!@
需求3:判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致
举例：aaa123aaa bbb456bbb 111789111 &&abc&&
public class regex_5 {
public static void main(String[] args) {
//举例：a123a b456b 17891 &abc&
// \\组号,表示把第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("&abc%".matches(regex1));
System.out.println("--------------------------");
// 判断一个字符串的开始部分和结束部分是否一致？可以有多个字符
//举例：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("--------------------------");
//判断一个字符串的开始部分和结束部分是否一致？开始部分内部每个字符也需要一致
//举例：aaa123aaa bbb456bbb 111789111 &&abc&&
String regex3 = "((.)\\2*).+\\1";
//(.):第一个字符看作一组
//\\1:把第一个字符再次使用
//* : 作用于\\1,后面的内容出现0次或多次
System.out.println("aaa123aaa".matches(regex3));
System.out.println("bbb456bbb".matches(regex3));
System.out.println("111789111".matches(regex3));
System.out.println("&&abc&^".matches(regex3));
}
}
捕获分组
后续还要使用本组的数据.
正则内部使用 : \\组号
正则外部使用 : $组号
练习: 口吃替换
需求: 将字符串 : 我要学学学编编编编编程程程程程程程程程
替换成 : 我要学编程
public static void main(String[] args) {
String s = "我要学学学编编编编编程程程程程程程程程";
String s1 = s.replaceAll("(.)\\1+", "$1");
//(.) 表示把重复内容的一个字符看作一组
// \\1+再次出现一次或多次
//$1 把正则表达式中的第一组内容再拿出来用
System.out.println(s1);
}
非捕获分组
分组之后不需要用本组数据, 仅仅是把手机括起来.
(? : 正则) (? = 正则) (? ! 正则) 可以删掉不写
总结
1.正则表达式中分组有两种:
捕获分组、非捕获分组
- 捕获分组（默认）：
可以获取每组中的内容反复使用。
- 组号的特点：
从1开始，连续不间断 以左括号为基准，最左边的是第一组
- 非捕获分组：
分组之后不需要再用本组数据，仅仅把数据括起来，不占组号。
(??(?=)(?!)都是非捕获分组