- 常用API
- **Object**
- Objects
- StringBuider
- Math
- System
- BigDecimal
- Date
- SimpleDateFormat
- Calendar
- 一个类要么默认继承了Object类，要么间接继承了Object类，Object类是java中的祖宗类
- Object类的方法是一切子类都可以直接使用的，所有我们要学习Object类的方法
- 常用的方法：toString()、equals()
toString()存在的意义
默认是打印当前对象的地址
父类toString()方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息！！！
equals()默认是比较当前对象与另一个对象的地址是否相同，返回true/false
- 直接比较两个对象的地址是否相同完全可以用”==”代替equals
- 父类equals存在的意义就是为了被子类重写，以便子类自己来定制比较规则
Object类下toString()源码
public String toString() {
return getClass().getName() + "@" +Integer.toHexString(hashCode());
}
Object类下equals()源码
public boolean equals(Object obj) {
return (this == obj);
//this当前对象的地址，地址的比较
}
举例：Person类（并没有重写toString、equals）
package test;
public class Person {
private int age;
private String name;
public Person() {
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package test;
public class Test2 {
public static void main(String[] args) {
Person boy1 = new Person(18,"小明");
Person boy2 = new Person(18,"小明");
System.out.println(boy1);
System.out.println(boy1.toString());
System.out.println(boy1.equals(boy2));//对象.equals(对象)，false，比较地址，两个对象的地址不一样
}
}
输出结果
test.Person@1b6d3586 test.Person@1b6d3586 false
在Person类下重写两个方法
package test;
import java.util.Objects;
public class Person {
private int age;
private String name;
public Person() {
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {//toString+Enter即可（快捷生产），也可以自己定义
return "Person{" +
"age=" + age +
", name='" + name + ''' +
'}';
}
@Override
public boolean equals(Object o) {//equals+enter它会提示，你一路next即可
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
}
输出结果
Person{age=18, name='小明'}
Person{age=18, name='小明'}
true
Objects
- Objects工具类（一般加s的都是工具类居多）与Object还是继承关系，Objects类是从JDK1.7开始之后才有的
- 官方在进行字符串比较时，没有用对象自己的equals方法，而是选择了Objects的equals方法来比较两个对象
- Objects的equals方法比较的结果是一样的，但是更安全
- 还提供了isNull(Object obj)方法，判断是否为null，是就返回true……
为什么Objects类的equals方法更加安全？
Objects下的源码
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
在比较两个对象时，用Object提供的equals方法时，需要对象来调用，但当该对象为null时，你去调用equals方法时就会报空指针异常
而Objects类的equals方法就是解决这个问题
public class Test_Objects_equals {
public static void main(String[] args) {
String str1 = null;
String str2 = "in";
// System.out.println(str1.equals(str2));//会报错，空指针异常
System.out.println(Objects.equals(str1,str2));//更加安全
System.out.println(Objects.isNull(str1));//true
}
}
StringBuider
- 可变的字符串类，我们可以把它看成是一个对象容器
- 作用：提高字符串的操作效率，如拼接、修改等
为什么说效率更高？
我觉得这篇文章解释的挺好的
http://t.csdn.cn/bIVtr
代码自己跑一跑看一下
package api_stringbuilder;
public class StringBuilderDemo1 {
public static void main(String[] args) {
StringBuilder string = new StringBuilder();
string.append("a");
System.out.println(string);
System.out.println(string.length());
string.append("b").append("c").append("d");//支持链式编程
System.out.println(string);
string.reverse().append("反转完了");
System.out.println(string);
String str = string.toString();//转回String
String target1 = "ab"+"cd";
StringBuilder target2 = new StringBuilder();
target2.append("ab").append("cd");
}
}
Math
- 包含执行基本数组运算的方法，Math类没有提供公开的构造器（实际上为工具类）
- 静态成员，通过类名可以直接调用
经常用到的方法
package api_stringbuilder;
public class MathDemo {
public static void main(String[] args) {
System.out.println(Math.abs(-100));//取绝对值
System.out.println(Math.ceil(4.001));//向上取整
System.out.println(Math.floor(4.999));//向下取整
System.out.println(Math.pow(2,3));//求指数次方，后面为指数
System.out.println(Math.round(4.68));//四舍五入
System.out.println(Math.random());//0.0~1.0（包前不包后）
}
}
System
- 用类名调用，不能被实例化
package api_stringbuilder;
public class SystemDemo {
public static void main(String[] args) {
// System.out.println("程序开始.。。。");
// System.exit(0);//非零表示异常终止，JVM停止
// System.out.println("程序结束");//并没有运行
//计算机认为时间有起源：返回1970/1/1 00:00:00走到此刻的毫秒值
long time = System.currentTimeMillis();//用途：性能分析
System.out.println(time);
}
}
BigDecimal
- 大数据类型
- 用于解决浮点型运算精度失真的问题
浮点数直接进行加减乘除运算时会出现数据失真（精度问题）
直接使用浮点数运算时
public static void main(String[] args) {
System.out.println(0.09+0.01);
System.out.println(1.0-0.32);
System.out.println(1.015*100);
System.out.println(1.301/100);
}
运算结果是
0.09999999999999999 0.6799999999999999 101.49999999999999 0.013009999999999999
显然这不是我们想要的结果
转成BigDecimal运算
package api_stringbuilder;
import java.math.BigDecimal;
public class TestBig {
public static void main(String[] args) {
BigDecimal num1 = BigDecimal.valueOf(0.09);//转成BigDecimal类型
System.out.println(num1.add(BigDecimal.valueOf(0.01)));//加法
BigDecimal num2 = BigDecimal.valueOf(1.0);
System.out.println(num2.subtract(BigDecimal.valueOf(0.32)));//减法
BigDecimal num3 = BigDecimal.valueOf(1.015);
System.out.println(num3.multiply(BigDecimal.valueOf(100)));//乘法
BigDecimal num4 = BigDecimal.valueOf(1.301);
System.out.println(num4.divide(BigDecimal.valueOf(100)));//除法
}
}
运算结果
0.10 0.68 101.500 0.01301
注意：在做除法运算的时候，如果除不尽，编译的时候不会报错，运行时会报异常（java.lang.ArithmeticException），这个时候你要给它一个处理“除不尽”状况的标准，例如保留多少位小数，四舍五入
import java.math.BigDecimal;
public class BigDecimalDemo {
public static void main(String[] args) {
double a = 10.0;
double b = 3.0;
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
BigDecimal c1 = a1.divide(b1,2,BigDecimal.ROUND_HALF_UP);//除,除不尽的话会报错，所有要指定参数,四舍五入
System.out.println(c1);//输出结果：3.33
}
}
虽然说BigDecimal类型运算可以保证精确度，但在开发中我们还是用浮点数类型较多，所以运算结果应该转回浮点数类型
//接上 double d = c1.doubleValue();//转成doubleDate
- 其对象在Java中代表当前所在系统的此刻日期时间
import java.util.Date;
public class DateDemo1 {
public static void main(String[] args) {
Date date1= new Date();
System.out.println(date1);//当前时间，如Tue May 03 15:19:57 CST 2022
long time = date1.getTime();//获取时间毫秒值，如1651562397768
System.out.println(time);
}
}
SimpleDateFormat
- 可以把Date对象或者时间毫秒值格式化成我们喜欢的时间形式，年月日+时分秒
- 也可以把字符串的时间形式解析成日期对象
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
public static void main(String[] args) {
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//API里面有格式，自己可以去看看
System.out.println(simpleDateFormat.format(date));//格式化日期对象
System.out.println(simpleDateFormat.format(12000000));//格式化时间毫秒值
String date1 = "2021-08-06 11:11:11";//注意全部是英文格式
try {
//用代码去做一些时间计算问题，题目我给忘了QAQ
Date nowDate = simpleDateFormat.parse(date1);
long target =nowDate.getTime()+(2l*24*60*60+14*60*60+49*60+6)*1000;//2l防止溢出 long型
System.out.println(simpleDateFormat.format(target));
} catch (ParseException e) {
e.printStackTrace();
}
}
}
//输出：
2022-05-03 15:27:39//不同时间结果也会有所不同
1970-01-01 11:20:00
2021-08-09 02:00:17
Calendar
- 代表了系统此刻日期对应的日历对象
- 是一个抽象类，不能直接创建对象，通过方法创建对象Calendar calendar = Calendar.getInstance();
常用方法
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
//拿到系统此刻日历对象,通过调用方法
Calendar calendar = Calendar.getInstance();
System.out.println(calendar);//会输出一长串东西，在里面可以找到年月日这些
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月
int month = calendar.get(Calendar.MONTH)+1;//记得加一
int weekday = calendar.get(Calendar.DAY_OF_WEEK)-1;//从周日开始，周日为1，要输出周几就-1
System.out.println("今天是周"+weekday);
System.out.println(year+"年"+month+"月");
//修改字段
calendar.set(Calendar.YEAR,2030);//换成2030年
System.out.println(calendar.get(Calendar.YEAR)+"年"+month+"月");
}
}
JDK8开始新增的日期类，java.time包
- LocalDate:不包含具体时间的日期
- LocalTime:不包含日期的时间
- LocalDateTime：包含了日期及时间
- Instant:代表的是时间戳
- DateTimeFormatter:用于做时间的格式化和解析的
- Duration:用于计算两个“时间”间隔
- Period:用于计算两个“日期”间隔
（真的超多啊，这我就不多讲了，代码放出来，自己来跑一下）
package date;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Date;
public class NewAdd {
public static void main(String[] args) {
LocalDate time1 = LocalDate.now();
System.out.println(time1);
System.out.println(time1.getDayOfWeek());
System.out.println(time1.getDayOfWeek().getValue());
LocalTime time2 = LocalTime.now();
System.out.println(time2);
LocalDateTime time3 = LocalDateTime.now();
System.out.println(time3);
System.out.println(time3.toLocalDate());//转化
System.out.println(time3.toLocalTime());
System.out.println(time2.plusHours(2));//加两小时，新对象
System.out.println(time2);//不可变对象，还是原来的
LocalDate myDate = LocalDate.of(2022,6,25);
System.out.println("今天是ta的生日吗n"+(time1.equals(myDate)==true?"是的":"不是"));
boolean flag = myDate.isAfter(time1);//顾名思义
System.out.println(flag);
MonthDay birthday = MonthDay.of(6,25);//设置
MonthDay nowDate = MonthDay.from(myDate);//从里面拿月日对象
if(birthday.equals(nowDate)){
System.out.println("今天是她的生日");
}else{
System.out.println("今天不是她的生日");
}
System.out.println("---------------------------");
//1、得到一个时间戳（年月日时分秒）对象
Instant instant = Instant.now();
System.out.println(instant);//我们在东8区，有时间差
//2、系统此刻时间戳
System.out.println(instant.atZone(ZoneId.systemDefault()));
//3、如何转成Date对象,两者可以互转，类似
Date date = Date.from(instant);
System.out.println(date);
System.out.println("---------------------------");
//本地日期时间对象
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
//解析/格式化
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
//正向格式化,与下面结果一样
System.out.println(dtf.format(ldt));
//逆向格式化
System.out.println(ldt.format(dtf));
//解析字符串时间
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime localDateTime = LocalDateTime.parse("2022-03-30 19:45:08",dtf1);
System.out.println(localDateTime);
}
}
package date;
import java.time.LocalDate;
import java.time.Period;
public class NewAdd1 {
public static void main(String[] args) {
LocalDate today = LocalDate.now();
System.out.println(today);
LocalDate birthday = LocalDate.of(2001,5,21);
System.out.println(birthday);
Period period = Period.between(birthday,today);//第二个参数减第一个参数
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
//Duration时间间隔，天，时分秒，毫秒、纳秒
}
}
- 新增的API严格区分了时刻，本地日期、本地时间，并且对时间运算更加方便
- 新API的类型几乎全是不变类型（和String的使用类似），可以放心使用不必担心被修改
待续~~~~
