Java学习（3）：常用API
目录
- 一、常用API
-
-
- 1. Object
- 2. Objects
- 3.StringBuilder
- 4.Math
- 5. System
- 6.BigDecimal
- 7.日期处理
- 5. Java8 新增日期类
-
-
- 1 .LocalTime、LocalDate、LocalDateTime
- 2.Instant
- 3.DateTimeFormater
- 4.Duration/Period
- 5.ChronoUnit
-
- 6. 包装类
- 7. Araays类
-
- 二、 正则表达式
- 三、 Lambda表达式
一、常用API
API就是java帮我们写好的一些方法，直接拿过来用就可以了。
1. Object
Object是所有类的父类，object所有的方法，子类都能使用。
object类的常用方法：
String toString() 返回该对象在堆内存中的地址信息。 @开头
boolean equals(Object o) 比较两个对象的地址是否相同。
2. Objects
objects是一个工具类，提供了一些方法去完成一些功能。
- Objects.equals(Object a,Object b);
Student student = new Student();
student.name = "join";
Student student1 = new Student();
student1.name = "join";
System.out.println(student == student1); //false
System.out.println(student.equals(student1)); //false 可能为空抛出异常
System.out.println(Objects.equals(student,student1)); //false 自动判断是否为空 不为空再判断是否一致 更安全
System.out.println(Objects.equals(student.name,student1.name)); //true
System.out.println(student.name.equals(student1.name)); //true
- boolean isNull(Object obj) 判断变量是否为null 如果是空则返回true
Student s = null;
System.out.println(Objects.isNull(s)); //true
System.out.println(s == null); //true
3.StringBuilder
StringBuilder是一个可变的字符串的操作类，可以看做是一个容器。
操作字符串的性能比String更高，拼接修改等。
构造器
StringBuilder(); 创建一个空白的字符串对象。
StringBuilder(String str); 创建一个制定字符串内容的可变字符串对象。
常用方法
StringBuilder append(任意类型) 添加输入并返回StringBuilder对象本身
StringBuilder reverse() 将内容反转
int length() 返回对象内容长度
String toString() 转换成String
insert(int index,String str) 在指定位置插入值
delete(int begin,int end) 从指定位置开始删除 到end结束
StringBuilder sb = new StringBuilder();
sb.append("开头"); //追加内容
sb.append("中间");
sb.insert(0,"在0插入"); //"在0插入开头中间";
sb.reverse(); //反转
sb.delete(1,4); //删除索引1到4的字符串 //在开头中间
System.out.println(sb.toString());
4.Math
Math类提供了基本数字运算的方法。
System.out.println(Math.abs(-9)); //绝对值 9
System.out.println(Math.max(40,45)); //最大值 45
System.out.println(Math.min(33.3f,33.2f)); //最小值 33.2
System.out.println(Math.pow(2,3)); //a的几次方 8.0
System.out.println(Math.round(10.50f)); //四舍五入 11
System.out.println(Math.random()); //随机数 0.0-0.1之间 0.41376494064030067
System.out.println(Math.ceil(10.000001)); //向上取整 11.0
System.out.println(Math.floor(10.9)); //向下取整 10.0
5. System
System的功能是通用的
exit(int status) 终止当前运行的java虚拟机，非0表示异常终止。
currentTimeMilis() 返回当前系统的时间毫秒值形式。
arraycopy() 拷贝数组 拷贝arr1，从0开始拷贝，拷贝到arr2，从0开始拷贝，拷贝长度。
System.out.println(System.currentTimeMillis()); //1679226525929 1970-01-01 开始的时间戳
int[] arr1 = {10,20,30,40,50};
int[] arr2 = new int[4];
System.arraycopy(arr1,0,arr2,0,4);
System.out.println(Arrays.toString(arr1));
//[10, 20, 30, 40, 50]
System.out.println(Arrays.toString(arr2));
//[10, 20, 30, 40]
6.BigDecimal
高精度浮点运算
不建议这种方式 BigDecimal(double) 精度问题 可以使用字符串的构造方法
//原因：计算机二进制中，表示浮点数不精确造成。
System.out.println(0.09 + 0.01); //0.09999999999999999
System.out.println(1.0 - 0.32); //0.6799999999999999
System.out.println(1.015 * 100); //101.49999999999999
System.out.println(1.301 / 100); //0.013009999999999999
BigDecimal b1 = new BigDecimal("0.09"); //字符串
BigDecimal b2 = BigDecimal.valueOf(0.01); //浮点数建议用valueOf
//加法
System.out.println(b1.add(b2)); //0.10
//减法
System.out.println(b1.subtract(b2));//0.08
//乘法
System.out.println(b1.multiply(b2));//0.0009
//除法 第二个参数保留几位小数,有可能除不尽的时候会报错
System.out.println(b1.divide(b2, 2));//9.00
BigDecimal b3 = new BigDecimal("1.601");
BigDecimal b4 = new BigDecimal("101");
System.out.println(b3.divide(b4,4));//0.146
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_UP));//0.15 //直接进位，比如1.21如果保留1位小数，得到的就是1.3
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_DOWN)); //0.14 //直接省略多余的小数，比如1.28如果保留1位小数，得到的就是1.2
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_UP)); //0.15 //四舍五入，2.35保留1位，变成2.4
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_DOWN)); //0.15 //四舍五入，2.35保留1位，变成2.3
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_CEILING)); //0.15 //向上取整 小数点进1
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_FLOOR)); //0.14 //向下取整 小数点舍弃
7.日期处理
- Date
时间原点：公园1970年1月1日，午夜0点。 毫秒值是0；
Date date1 = new Date();
date1.getTime();
System.out.println(date1.getTime() == System.currentTimeMillis()); // true
System.out.println(System.currentTimeMillis());
Date date2 = new Date(1679228756063l);
- SimpleDateFormat
日期格式化
public static void main(String[] args) throws ParseException {
Date date1 = new Date();
System.out.println(date1); //Sun Mar 19 20:42:01 CST 2023
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = sdf.format(date1);
System.out.println(dateStr); //2023-03-19 20:42:18
System.out.println(sdf.format(System.currentTimeMillis())); //2023-03-19 20:43:52
Date date2 = sdf.parse(dateStr);
System.out.println(date2); //Sun Mar 19 20:42:01 CST 2023
}
parse方法可能提供的格式不对 转换失败所以需要抛出一个异常
- Calendar
日历对象 抽象类，替换了很多Date中的方法。
//get() 方法 获取日历字段
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);
System.out.println(year+"-"+month+"-"+day);
//Set() 方法 设置日历字段
Calendar c1 = Calendar.getInstance();
c1.set(Calendar.YEAR,2088);
c1.set(2099,4,5);
c1.set(2099,4,5,12,30,0);
//add() 方法
c1.add(Calendar.DATE,5); //添加5天
c1.add(Calendar.DATE,-5); //减少5天
//活了多少天
Calendar my = Calendar.getInstance(); //得到此刻时间戳
Calendar c2 = Calendar.getInstance();
my.set(1991,0,11);
long day1 = c2.getTimeInMillis();
long myDay = my.getTimeInMillis();
System.out.println((day1-myDay)/1000/60/60/24);
Date d = my.getTime();
System.out.println(d); //转日期 Fri Jan 11 20:49:18 CST 1991
5. Java8 新增日期类
1 .LocalTime、LocalDate、LocalDateTime
他们分别代表， 时间，日期，时间日期对象。他们的类的实例是不可变的对象，每次改变是新的对象。
now() 获取当前时间
LocalDate ld = LocalDate.now(); //获取当前日期
LocalTime lt = LocalTime.now(); //获取当前时间
LocalDateTime ldt = LocalDateTime.now(); //获取当前日期时间
System.out.println(ld);// 2023-03-19
System.out.println(lt); //20:55:42.446
System.out.println(ldt); //2023-03-19T20:55:42.446
of() 创建时间
LocalDate ld1 = LocalDate.of(2023,3,15); //创建日期
LocalTime lt1 = LocalTime.of(21,30,30); //创建时间
LocalDateTime ldt1 = LocalDateTime.of(2023,2,3,4,5,40); //创建日期时间
System.out.println(ld1); //2023-03-15
System.out.println(lt1);//21:30:30
System.out.println(ldt1);//2023-02-03T04:05:40
获取年月日
int year = ldt.getYear(); //2023
int month = ldt.getMonthValue(); //3
int dayOfMonth = ldt.getDayOfMonth();//19
int dayOfYear = ldt.getDayOfYear(); //一年中第几天 78
DayOfWeek week = ldt.getDayOfWeek(); //星期几 SUNDAY
//LocalDateTime的转换
System.out.println(ldt.toLocalDate()); //转成日期 2023-03-19
System.out.println(ldt.toLocalTime()); //转成时间 21:01:40.454
操作时间
LocalDateTime ldt = LocalDateTime.now(); //获取当前日期时间
System.out.println(ldt);
//plus.. 加
ldt.plusDays(1); //加1天
ldt.plusHours(4); //加小时
ldt.plusMinutes(30); //加30分
ldt.plusSeconds(30); //加30秒
//minus.. 减
ldt.minusDays(1); //减1天
ldt.minusHours(4); //减4小时
ldt.minusMinutes(30); //减30分
ldt.minusSeconds(30); //减30秒
//with.. 将指定位置修改为指定值 返回新日期
ldt = ldt.withDayOfMonth(1); //设置为本月1号
ldt = ldt.withMinute(0); //设置为0分
System.out.println(ldt);
//比较两个日期
boolean before = ldt.isBefore(LocalDateTime.now());
boolean after = ldt.isAfter(LocalDateTime.now());
System.out.println(before); //true 之前
System.out.println(after); // false
2.Instant
时间戳
Instant instant = Instant.now();
System.out.println(instant);
Date date = Date.from(instant);
System.out.println(date);
instant = date.toInstant();
System.out.println(instant);
//比较
instant.isAfter(instant1);
instant.isBefore(instant1);
3.DateTimeFormater
日期格式化器
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
System.out.println(dtf.format(ldt)); //2023/03/20 19:26:13
System.out.println(ldt.format(dtf)); //正反都可以调用
//字符串时间解析
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
String dateStr = "2023/03/03 03:03:03";
LocalDateTime ldt1 = LocalDateTime.parse(dateStr,dtf);
4.Duration/Period
Period 用来计算日期差异。 只能精确到年月日。
LocalDate ld = LocalDate.of(1991,1,11);
LocalDate ld1 = LocalDate.now();
//隔了多少年 多少月 多少天
Period period = Period.between(ld,ld1);
System.out.println(period.getYears() + "-" + period.getMonths() +"-"+period.getDays());
Duration 计算时间间隔
LocalDateTime ldt = LocalDateTime.of(1991, 1, 11, 20, 0, 0);
LocalDateTime ldt1 = LocalDateTime.now();
Duration duration = Duration.between(ldt, ldt1);
System.out.println(duration.toDays());
System.out.println(duration.toHours());
System.out.println(duration.toMillis());
5.ChronoUnit
比较时间更全的api
LocalDateTime ldt = LocalDateTime.of(1991, 1, 11, 20, 0, 0);
LocalDateTime ldt1 = LocalDateTime.now();
System.out.println(ChronoUnit.DAYS.between(ldt,ldt1));
System.out.println(ChronoUnit.SECONDS.between(ldt,ldt1));
...
6. 包装类
八中基本类型的引用类型，提供了更多的方法，集合和泛型也只支持包装类型。
byte->Byte
short->Short
int->Integer
long->Long
char->Character
float->Float
double->Double
boolean->Boolean
Integer.parseInt("123"); //将字符串转换为int类型
//int转字符串
int num = 10;
System.out.println(num+""+12); //加双引号
//方法2:
Integer.toString(num);
常量两个：
Integer.MAX_VALUE 最大值
Integer.MIN_VALUE 最小值
自动装箱：基本数据类型直接变成对象
Integer i = 1; //Integer i = new Integer(1); 1转换成引用各类型 装箱
自动拆箱：对象中的数据变回基本类型
i++; //自动拆箱 引用类型会转换回基本类型做运算
包装类的默认值可以是null
7. Araays类
用来操作数组的
int [] arr = {3,56,55,3,5,44,2};
Arrays.sort(arr); //排序
//二分搜索（前提必须排好序才支持，否则出bug）
int i = Arrays.binarySearch(arr, 2); //找到该值的索引
System.out.println(i);
System.out.println(Arrays.toString(arr)); //输出字符串
//自定义数组排序规则 Comparator
//必须引用类型
Integer[] arr = {3, 56, 55, 3, 5, 44, 2};
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//return o1 < o2 ? 1 : -1; //如果大于返回正整数 否则返回负数
return o2 - o1;
}
});
System.out.println(Arrays.toString(arr));
二、 正则表达式
用来定义匹配规则，检查一个字符串是否符合该规则。
\ 转义
\n 换行
\r 回车
[abc] 范围abc中有一个即可
[^abc] 取反 不能有abc中的一个
[a-zA-Z] 小写a到z及大写A-Z中任何一个都可以
[0-9] 匹配数字0到9之内
[a-zA-Z_0-9] 匹配字母下划线数字
预定义字符：
\d 相当于0-9
\w 相当于a-zA-Z
^ 代表的是行的开头
$ 代表的是行的结尾
\b 单词边界
? 一次或一次也没有
- 0次或多次
- 一次或多次
{n} 正好n次
{n,} 至少n次
{n,m} 至少n次，最多m次。
字符串.matches(regex) 返回真假
public static boolean checkQQ(String qq){
boolean result = qq.matches("^[1-9][0-9]{4,9}$");
return result;
}
//检查手机
String str = "18513766853";
boolean matches = str.matches("[1][3-9](\\d){9}"); //是否满足条件
//检查邮箱
String email = "[email protected]";
boolean checkEmail = email.matches("[a-zA-Z0-9_]+@[a-zA-Z]+(\\.[a-z]+){1,2}");
System.out.print(checkEmail);
str.split(regex); //根据正则切割
String str = "192.168.0.2";
String[] strs = str.split("\\.+");
for(int i =0;i<strs.length;i++){
System.out.println(strs[i]);
}
str.replaceAll(regex); //根据正则替换
String str = "192.168.0.2";
str = str.replaceAll("\\.","*");
System.out.print(str);
//匹配对象
String str = "1851376685sdf's'fjal;ksdj'flkas'd3@[email protected]$%fasdfsadfa;a;com.cn";
Pattern p = Pattern.compile("[a-zA-Z0-9_]+@[a-zA-Z]+(\\.[a-z]+){1,2}"); //匹配
Matcher matcher = p.matcher(str);
while(matcher.find()){
System.out.println(matcher.group());
}
三、 Lambda表达式
Lambda表达式让你可以写出更简洁的代码。
// Arrays.sort(arr, new Comparator() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o1 < o2 ? 1 : -1; //正整数 或者 负数
// }
// });
Arrays.sort(arr,(Integer o1,Integer o2)->{return o1-o2;});
//具有一个String类型的参数 返回一个int Lambda没有return 语句，因为已经隐含了
(String s) -> s.length()
//Apple类型的参数 返回一个boolean
(Apple a) -> a.getWeight() > 150
//两个int参数 没有返回值
(int x, int y) ->{
System.out.println(x+y);
}
//空参数 返回int 42
() -> 42