Java.lang包下的常用API
标题一代码不会写就按CtrlAlt+空格键
一，Object类：
1，作用：
是Java中所有类的祖宗，因此，Java中所有类的对象都可以直接使用此类中提供的一些方法
2，toString
public class Test {
public static void main(String[] args) {
// 目标：掌握Object类提供的常用方法。
Student s1 = new Student("赵敏", 23);
// System.out.println(s1.toString());
System.out.println(s1);
s1返回的内容是一串地址，要想返回输入的内容，需要在创建的学生类中方法重写
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//方法重写：：：：
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
3,equals
equals和==都是默认比较对象的地址是否一样
Student s2 = new Student("赵敏", 23);
System.out.println(s2.equals(s1));
System.out.println(s2 == s1); //false
。开发中让子类重写equals方法，以便比较两个对象的内容是否相同
// 重写equals方法,比较两个对象的内容一样就返回true.
// 比较者：s2 == this
// 被比较者：s1 == o
//写equals，然后一直回车回车回车直至写好
@Override
public boolean equals(Object o) {
// 1、判断两个对象是否地址一样，一样直接返回true.
if (this == o) return true;
// 2、判断o是null直接返回false, 或者比较者的类型与被比较者的类型不一样，返回false
// Student.class != Pig.class
if (o == null || this.getClass() != o.getClass()) return false;
// 3、o不是null，且o一定是学生类型的对象。开始比较内容了！
Student student = (Student) o;
return this.age == student.age && Objects.equals(this.name, student.name);
}4，clone（了解）
当某个对象调用这个方法时，这个方法会复制一个一模一样的新对象返回
1，浅克隆
2，深克隆
二，Objects类：
是一个工具类，提供了很多操作对象的静态方法给我们使用
public class Test {
public static void main(String[] args) {
// 目标：掌握Objects类提供的常用方法。
String s1 = null;
String s2 = "itheima";
// System.out.println(s1.equals(s2));
System.out.println(Objects.equals(s1, s2)); // 更安全，更好的！
System.out.println(Objects.isNull(s1)); // true
System.out.println(s1 == null); // true
System.out.println(Objects.isNull(s2)); // false
System.out.println(s2 == null );// false
System.out.println(Objects.nonNull(s2)); // true
System.out.println(Objects.nonNull(s1)); // false
}
}
三，包装类：（重要）
就是把基本类型的数据包装成对象
自动装箱：基本数据类型可以自动转换为包装类型
自动拆箱：包装类型可以自动 转换为基本数据类型
public class Test {
public static void main(String[] args) {
// 目标：掌握包装类的使用。
// Integer a1 = new Integer(12); //过时
Integer a2 = Integer.valueOf(12);
System.out.println(a2);
// 自动装箱：可以自动把基本类型的数据转换成对象。
Integer a3 = 12;
// 自动拆箱：可以自动把包装类型的对象转换成对应的基本数据类型。
int a4 = a3;
// 泛型和集合不支持基本数据类型，只能支持引用数据类型。
// ArrayList list = new ArrayList<>(); //报错
ArrayList list = new ArrayList<>();
list.add(12); // 自动装箱
list.add(13); // 自动装箱
int rs = list.get(1); // 自动拆箱
System.out.println("--------------------------------------------------");
// 1、把基本类型的数据转换成字符串
Integer a = 23;
String rs1 = Integer.toString(a); // "23"
System.out.println(rs1 + 1); // 231
String rs2 = a.toString(); // "23"
System.out.println(rs2 + 1);
String rs3 = a + "";
System.out.println(rs3 + 1);
// 2、把字符串类型的数值转换成对应的基本类型。
String ageStr = "29";
// int ageI = Integer.parseInt(ageStr); // 29
int ageI = Integer.valueOf(ageStr); // 29
System.out.println(ageI + 1); // 30
String scoreStr = "99.5";
// double score = Double.parseDouble(scoreStr); // 99.5
double score = Double.valueOf(scoreStr); // 99.5
System.out.println(score + 0.5);
}
}
其他常见操作：*********
四，StringBuilder, StringBuffer,StringJoiner
1，拼接内容
//StringBuilder s = new StringBuilder();无参构造器
StringBuilder s = new SringBuilder("ithema");//有参构造器
//1,拼接内容 append(任意类型)
s.append(12);
s.append("黑马");
s.append(true);
//支持链式编程
s.append(666).append("黑马2").append(666);
System.out.println(s);//ithema12黑马true666黑马26662，反转操作
s.reverse();
System.out.println(s);3,返回字符串长度
s.length();再打印出来
4，把StringBuilder对象又转换成String类型
String rs = s.toString();
System.out.println(rs);
StringBuffer和StringBuilder的区别：StringBuffer和StringBuilder的用法是一模一样的
StringBuffer是线路不安全的，StringBuilder是线路安全的
StringJoiner和StringBuilder的区别： StringJoiner与StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的
好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁
StringJoiner s = new StringJoiner(", " , "[" , "]");//间隔符号，开始符号，结束符号
s.add("Java1");
s.add("Java2");
s.add("Java3");
System.out.println(s);//[java1,java2,java3]
五，Math,System,Runtime
终止虚拟机的方法不用
方法2返回当前系统的毫秒值 非常重要
如下输出的是for循环程序的执行时间
long time = System.currentTimeMillis();
System.out.println(time);
for(int i = 0; i < 1000000; ++i) {
System.out.println("输出了：" + i);
}
long time2 = System.currentTimeMillis();
System.out.println((double)(time2 - time) / 1000.0 + "s");
六，BigDecimal
public static void main(String[] args) {
// 目标：掌握BigDecimal进行精确运算的方案。
double a = 0.1;
double b = 0.2;
// 1、把浮点型数据封装成BigDecimal对象，再来参与运算。
// a、public BigDecimal(double val) 得到的BigDecimal对象是无法精确计算浮点型数据的。 注意：不推荐使用这个，
// b、public BigDecimal(String val) 得到的BigDecimal对象是可以精确计算浮点型数据的。 可以使用。
// c、public static BigDecimal valueOf(double val): 通过这个静态方法得到的BigDecimal对象是可以精确运算的。是最好的方案。
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
加减乘除
BigDecimal c1 = a1.add(b1);
System.out.println(c1);
// 3、public BigDecimal subtract(BigDecimal augend): 减法
BigDecimal c2 = a1.subtract(b1);
System.out.println(c2);
// 4、public BigDecimal multiply(BigDecimal augend): 乘法
BigDecimal c3 = a1.multiply(b1);
System.out.println(c3);
// 5、public BigDecimal divide(BigDecimal b): 除法
BigDecimal c4 = a1.divide(b1);
System.out.println(c4); // 6、public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式) : 除法，可以设置精确几位。
BigDecimal d1 = BigDecimal.valueOf(0.1);
BigDecimal d2 = BigDecimal.valueOf(0.3);
BigDecimal d3 = d1.divide(d2, 2, RoundingMode.HALF_UP); // 0.33
System.out.println(d3);
// 7、public double doubleValue() : 把BigDecimal对象又转换成double类型的数据。
//print(d3);
//print(c1);
double db1 = d3.doubleValue();
double db2 = c1.doubleValue();
print(db1);
print(db2);七，jdk8之前传统的日期，时间
1，Date
1970年1月1日 00：00：00
// 1、创建一个Date的对象：代表系统当前时间信息的。
Date d = new Date();
System.out.println(d);
// 2、拿到时间毫秒值。
long time = d.getTime();
System.out.println(time);//time是系统当前的时间毫秒值
// 3、把时间毫秒值转换成日期对象： 如需求是2s之后的时间是多少。
time += 2 * 1000;
Date d2 = new Date(time);
System.out.println(d2);
// 4、直接把日期对象的时间通过setTime方法进行修改
Date d3 = new Date();
d3.setTime(time);
System.out.println(d3);2，SimpleDateFormat简单日期格式化
// 目标：掌握SimpleDateFormat的使用。
// 1、准备一些时间
Date d = new Date();
System.out.println(d);
long time = d.getTime();
System.out.println(time);
// 2、格式化日期对象，和时间 毫秒值。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
// 小时 分 秒 周几 上午还是下午
String rs = sdf.format(d); //格式化日期对象
String rs2 = sdf.format(time);//格式化时间毫秒值
System.out.println(rs); //输出2023年11月24日 21：17：55 周五 下午
System.out.println(rs2);
System.out.println("-------------------------------------------------------------------");
重要：
// 目标：掌握SimpleDateFormat解析字符串时间 成为日期对象。
String dateStr = "2022-12-12 12:12:11";
// 1、创建简单日期格式化对象 , 指定的时间格式必须与被解析的时间格式一模一样，否则程序会出bug.
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d2 = sdf2.parse(dateStr);
System.out.println(d2);秒杀案例： 把字符串的时间解析成日期对象。
把日期对象转换成时间毫秒值来判断
3，Calendar日历
。代表的是系统此刻时间对应的日历
。通过它可以单独获取，修改时间中的年，月，日，时，分，秒等
Calendar类是一个抽象类，不能创建对象，所以不能直接使用。Calendar提供了一个类方法getInstance,用于获取此类型的通用对象
Calendar rightNow =Calendar.getInstance();
// 1、得到系统此刻时间对应的日历对象。
Calendar now = Calendar.getInstance();
System.out.println(now);//输出全部信息
// 2、获取日历中的某个信息
int year = now.get(Calendar.YEAR);
System.out.println(year);
int days = now.get(Calendar.DAY_OF_YEAR);
System.out.println(days);
// 3、拿到日历中记录的日期对象。
Date d = now.getTime();
System.out.println(d);
// 4、拿到时间毫秒值
long time = now.getTimeInMillis();
System.out.println(time);月份是从0开始记录的：
// 5、修改日历中的某个信息
now.set(Calendar.MONTH, 9); // 修改月份成为10月份。
now.set(Calendar.DAY_OF_YEAR, 125); // 修改成一年中的第125天。
System.out.println(now);
// 6、为某个信息增加或者减少多少
now.add(Calendar.DAY_OF_YEAR, 100);
now.add(Calendar.DAY_OF_YEAR, -10);
now.add(Calendar.DAY_OF_MONTH, 6);
now.add(Calendar.HOUR, 12);
now.set(2026, 11, 22);
System.out.println(now);Calendar是可变对象，一旦修改后其对象本身表示的时间将产生变化
八，jdk8开始新增的日期，时间
能精确到毫秒，纳秒。线程安全。都是不可变对象
1s=1000ms;1ms=1000微秒；1微秒=1000纳秒
1，代替Calendar
LocalDate,LocalTime,LocalDateTime
localdate的用法：
// 0、获取本地日期对象(不可变对象！！！！！！！！！)
LocalDate ld = LocalDate.now(); // 年 月 日
System.out.println(ld);
// 1、获取日期对象中的信息
int year = ld.getYear(); // 年
int month = ld.getMonthValue(); // 月(1-12)
int day = ld.getDayOfMonth(); // 日
int dayOfYear = ld.getDayOfYear(); // 一年中的第几天
int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几
System.out.println(year);
System.out.println(day);
System.out.println(dayOfWeek);
// 2、直接修改某个信息: withYear、withMonth、withDayOfMonth、withDayOfYear
LocalDate ld2 = ld.withYear(2099);
LocalDate ld3 = ld.withMonth(12);
System.out.println(ld2);
System.out.println(ld3);
System.out.println(ld);
// 3、把某个信息加多少: plusYears、plusMonths、plusDays、plusWeeks
LocalDate ld4 = ld.plusYears(2);
LocalDate ld5 = ld.plusMonths(2);
// 4、把某个信息减多少：minusYears、minusMonths、minusDays、minusWeeks
LocalDate ld6 = ld.minusYears(2);
LocalDate ld7 = ld.minusMonths(2);
// 5、获取指定日期的LocalDate对象： public static LocalDate of(int year, int month, int dayOfMonth)
LocalDate ld8 = LocalDate.of(2099, 12, 12);
LocalDate ld9 = LocalDate.of(2099, 12, 12);
// 6、判断2个日期对象，是否相等，在前还是在后： equals isBefore isAfter
System.out.println(ld8.equals(ld9));// true
System.out.println(ld8.isAfter(ld)); // true
System.out.println(ld8.isBefore(ld)); // false
}
}
localtime的用法基本与localdate一样
LocalTime lt = LocalTime.now(); // 时 分 秒 纳秒 不可变的 System.out.println(lt);
int nano = lt.getNano(); //纳秒
LocalTime lt6 = lt.withNano(10);
// 5、获取指定时间的LocalTime对象： // public static LocalTime of(int hour, int minute, int second) LocalTime lt15 = LocalTime.of(12, 12, 12); LocalTime lt16 = LocalTime.of(12, 12, 12); localdatetime:
// 0、获取本地日期和时间对象。
LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒 纳秒
System.out.println(ldt);
// 1、可以获取日期和时间的全部信息
int year = ldt.getYear(); // 年
int month = ldt.getMonthValue(); // 月
int day = ldt.getDayOfMonth(); // 日
int dayOfYear = ldt.getDayOfYear(); // 一年中的第几天
int dayOfWeek = ldt.getDayOfWeek().getValue(); // 获取是周几
int hour = ldt.getHour(); //时
int minute = ldt.getMinute(); //分
int second = ldt.getSecond(); //秒
int nano = ldt.getNano(); //纳秒// 7、可以把LocalDateTime转换成LocalDate和LocalTime // public LocalDate toLocalDate() // public LocalTime toLocalTime() // public static LocalDateTime of(LocalDate date, LocalTime time) LocalDate ld = ldt.toLocalDate(); LocalTime lt = ldt.toLocalTime(); LocalDateTime ldt10 = LocalDateTime.of(ld, lt);//合体
ZoneId时区,ZonedDateTime带时区的时间
ZoneId代表时区Id
ZoneId的常见方法：
// public static ZoneId systemDefault(): 获取系统默认的时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId.getId());
System.out.println(zoneId);//输出结果相同
// public static Set getAvailableZoneIds(): 获取Java支持的全部时区Id
System.out.println(ZoneId.getAvailableZoneIds());
// public static ZoneId of(String zoneId) : 把某个时区id封装成ZoneId对象。
ZoneId zoneId1 = ZoneId.of("America/New_York");
ZoneDateTime:带时区的时间
// public static ZonedDateTime now(ZoneId zone): 获取某个时区的ZonedDateTime对象。
ZonedDateTime now = ZonedDateTime.now(zoneId1);
System.out.println(now);
// 世界标准时间
ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
System.out.println(now1);
// public static ZonedDateTime now()：获取系统默认时区的ZonedDateTime对象
ZonedDateTime now2 = ZonedDateTime.now();
System.out.println(now2);
// Calendar instance = Calendar.getInstance(TimeZone.getTimeZone(zoneId1));
}2，代替Date
Instant:时间戳/时间线上的某个时刻
常用方法
// 1、创建Instant的对象，获取此刻时间信息
Instant now = Instant.now(); // 不可变对象
// 2、获取总秒数
long second = now.getEpochSecond();
System.out.println(second);
// 3、不够1秒的纳秒数
int nano = now.getNano();
System.out.println(nano);
System.out.println(now);
Instant instant = now.plusNanos(111);
Instant对象的作用：做代码的性能分析，或者记录用户的操作时间点
Instant now1 = Instant.now();
// 代码执行。。。。
Instant now2 = Instant.now();
3，代替SampleDateFormat
DateTimeFormatter用于时间的格式化和解析
// 1、创建一个日期时间格式化器对象出来。
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
// 2、对时间进行格式化
LocalDateTime now = LocalDateTime.now(); //当前时间
System.out.println(now);//2023-11-25T16：04：55.171072
String rs = formatter.format(now); // 正向格式化
System.out.println(rs);//2023年11月25日 16：04：55
// 3、格式化时间，其实还有一种方案。
String rs2 = now.format(formatter); // 反向格式化
System.out.println(rs2);//2023年11月25日 16：04：55
// 4、解析时间：解析时间一般使用LocalDateTime提供的解析方法来解析。
String dateStr = "2029年12月12日 12:12:11";
LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
System.out.println(ldt);
}
}4，其它补充
Period：时间间隔（年，月，日）
可以用于计算LocalDateTime 对象相差的年数月数天数
LocalDate start = LocalDate.of(2029, 8, 10);
LocalDate end = LocalDate.of(2029, 12, 15);
// 1、创建Period对象，封装两个日期对象。
Period period = Period.between(start, end);
// 2、通过period对象获取两个日期对象相差的信息。
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());Duration:时间间隔（时，分，秒，纳秒）
支持LocalTime,LocalDateTime,Instant等时间
方法名：public static Duration between（开始时间对象1，截止时间对象2）
LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);
// 1、得到Duration对象
Duration duration = Duration.between(start, end);
// 2、获取两个时间对象间隔的信息
System.out.println(duration.toDays());// 间隔多少天
System.out.println(duration.toHours());// 间隔多少小时
System.out.println(duration.toMinutes());// 间隔多少分
System.out.println(duration.toSeconds());// 间隔多少秒
System.out.println(duration.toMillis());// 间隔多少毫秒
System.out.println(duration.toNanos());// 间隔多少纳秒