其他类
Object类
超类、基类，所有类的直接或间接父类，位于继承树的最高层
任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象：
作为参数，可接受任何对象
作为返回值，可接受任何对象
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name,int age){
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name = " + name + " , age = " + age + "]";
}
@Override
public boolean equals(Object obj) {
// 1. 判断俩个对象是否是同一个引用
if (this==obj){
return true;
}
// 2. 判断obj是否为null
if (obj == null){
return false;
}
// 3. 判断是否是同一个类型
if (obj instanceof Student){
// 4. 强制类型转换
Student s = (Student) obj;
// 5. 比较属性
if (this.name.equals(s.getName()) && this.age==s.getAge()){
return true;
}
}
return false;
}
}
// 测试类
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa",25);
Student s2 = new Student("bbb",35);
}
}
getClass()方法
语法：
public final Class getClass(){
}
返回引用中存储的实际对象类型
应用：通常用于判断俩个引用中实际存储对象类型是否一致
// getClass方法
// 判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2){
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("----------------------");
//运行结果：
// s1和s2属于同一个类型
hashCode()方法
语法：
public int hashCode(){
}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同哈希码值
// hashCode方法
System.out.println(s1.hashCode()); // 460141958
System.out.println(s2.hashCode()); // 1163157884
Student s3 = s1;
System.out.println(s3.hashCode()); // 460141958
System.out.println("----------------------");
toString()方法
语法：
public String toString(){
}
返回该对象的字符串表示（表现形式）
可以根据程序需要覆盖该方法，如：展示对象各个属性值（重写方法）
// toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println("----------------------");
运行结果：
Student [name = aaa , age = 25]
Student [name = bbb , age = 35]
equals()方法
语法：
public boolean equals(Object obj){
}
默认实现为（this == obj），比较俩个对象地址是否相同
可进行覆盖（重写），比较俩个对象的内容是否相同
// equals方法
System.out.println(s1.equals(s2)); // false
Student s4 = new Student("小明",18);
Student s5 = new Student("小明",18);
System.out.println(s4.equals(s5)); // true 重写方法后
运行结果：
false
true
equals()方法覆盖步骤
1. 比较俩个引用是否指向同一个对象
2. 判断obj是否为null
3. 判断俩个引用指向的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同
finalize()方法
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用 System.gc(); 通知JVM执行垃圾回收
完整代码
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name,int age){
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name = " + name + " , age = " + age + "]";
}
@Override
public boolean equals(Object obj) {
// 1. 判断俩个对象是否是同一个引用
if (this==obj){
return true;
}
// 2. 判断obj是否为null
if (obj == null){
return false;
}
// 3. 判断是否是同一个类型
if (obj instanceof Student){
// 4. 强制类型转换
Student s = (Student) obj;
// 5. 比较属性
if (this.name.equals(s.getName()) && this.age==s.getAge()){
return true;
}
}
return false;
}
}
// 测试类
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa",25);
Student s2 = new Student("bbb",35);
// getClass方法
// 判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2){
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("----------------------");
//运行结果：
// s1和s2属于同一个类型
// hashCode方法
System.out.println(s1.hashCode()); // 460141958
System.out.println(s2.hashCode()); // 1163157884
Student s3 = s1;
System.out.println(s3.hashCode()); // 460141958
System.out.println("----------------------");
// toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println("----------------------");
// equals方法
System.out.println(s1.equals(s2)); // false
Student s4 = new Student("小明",18);
Student s5 = new Student("小明",18);
System.out.println(s4.equals(s5)); // true 重写方法后
}
}
包装类
什么是包装类
Java的基本数据类型（如int、char、boolean等）是非对象的，不能直接参与面向对象的操作，也不能直接调用方法。为了解决这个问题，Java提供了对应的包装类。
包装类就是：基本数据类型所对应的引用数据类型
Object 可统一所有数据，包装类的默认值是 null
包装类对应
基本数据类型包装类型byteByteshortShortlongLongfloatFloatdoubleDoublebooleanBooleanintIntegercharCharacter类型转换与装箱、拆箱
8种包装类提供不同类型间的转换方式：
Number父类中提供的6个共性方法parseXXX ( )静态方法valueOf ( )静态方法
注意：需要保证类型兼容，否则抛出 NumberFromatException 异常
public class Demo01 {
public static void main(String[] args) {
// int num = 10;
// 类型转换： 装箱：基本类型转成引用类型的过程
// 基本类型
int num1 = 18;
// 使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer1);
System.out.println(integer2);
// 类型转型： 拆箱：引用类型转成基本类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
// 在JDK1.5之后，Java提供了自动装箱和自动拆箱
int age = 30 ;
// 自动装箱
Integer integer4 = age;
System.out.println("自动装箱");
System.out.println(integer4);
// 自动拆箱
int age2 = integer4;
System.out.println("自动拆箱");
System.out.println(age2);
System.out.println("=============基本类型和字符串之间转换==============");
// 基本类型和字符串之间转换
// 1. 基本类型转换成字符串
int n1 = 255;
int n2 = 15;
// 1-1 使用 + 相连
String s1 = n1+"";
String s2 = n2+"";
// 1-2 使用Integer中的 toString()方法
String s3 = Integer.toString(n1,16);
String s4 = Integer.toString(n2,16);
System.out.println(s1); // 255
System.out.println(s2); // 15
System.out.println(s3); // ff
System.out.println(s4); // f
// 2. 字符串转基本类型
String str = "150";
// 使用 Integer.parseXXX();
int n3 = Integer.parseInt(str);
System.out.println(n3); // 150
// boolean 字符串形式转成基本形式。 "true" --> true 非true --> false
String str2 = "true";
String str3 = "abcd";
boolean b1 = Boolean.parseBoolean(str2);
boolean b2 = Boolean.parseBoolean(str3);
System.out.println(b1); // true
System.out.println(b2); // false
}
}
整数缓冲区
Java预先创建了256个常用的整数包装类型对象
在实际应用中，对已创建的对象进行复用
// 整数缓冲区
public static void main(String[] args) {
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2); // false
// 自动装箱 Integer.valueOf
Integer integer3 = 100;
Integer integer4 = 100;
System.out.println(integer3==integer4); // true
Integer integer5 = 200;
Integer integer6 = 200;
System.out.println(integer5==integer6); // false
}
integer3 与 integer4 相等是因为：在整数缓冲区范围内（-128~127）
integer5 与 integer6 不相等是因为：范围（200）已经超出缓冲区范围，变为 使用new 关键字
String 类
定义
字符串是常量。创建之后不可改变
字符串字面值存储在字符串池中，可以共享
String s = “Hello” ; // 产生一个对象，字符串池中存储
String s = new String (“Hello”) ; // 产生俩个对象，堆、池各存储一个。
如图所示
在JDK1.7之前运行时常量池逻辑包含字符串常量池存放在方法区, 此时hotspot虚拟机对方法区的实现为永久代
在JDK1.7 字符串常量池被从方法区拿到了堆中, 这里没有提到运行时常量池,也就是说字符串常量池被单独拿到堆,运行时常量池剩下的东西还在方法区, 也就是hotspot中的永久代
在JDK1.8 hotspot移除了永久代用元空间(Metaspace)取而代之, 这时候字符串常量池还在堆, 运行时常量池还在方法区, 只不过方法区的实现从永久代变成了元空间(Metaspace)
String name = "hello"; // "hello" 常量存储在字符串池中
name = "zhangsan"; // "zhangsan" 赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
String name2 = "zhangsan";
System.out.println(name==name2); // true
// 演示字符串的另一种创建方式， new String();
String str = new String("java");
String str2 = new String("java"); // 在堆的空间新开辟了str2，虽然指向的是同一个数据，但是地址是不一样的
System.out.println(str==str2); // false 使用 == 比较的是地址
System.out.println(str.equals(str2)); // true 使用 equals 比较的是数据
常用方法
public int length () ; 返回字符串的长度
public char charAt (int index) ; 根据下标获取字符
public boolean contains (String str) ; 判断当前字符串中是否包含str
// 字符串方法的使用
// 1. length(); 返回字符串的长度 注意：这里空格也算一个字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个子字符串
String s = "Java是世界上最好的编程语言,Java就是最简单的,Java最好";
System.out.println(s.length()); // 15
System.out.println(s.charAt(5)); // 世
System.out.println(s.charAt(s.length()-1)); // 言
System.out.println(s.contains("java")); // false
System.out.println(s.contains("Java")); // true
System.out.println(s.contains("JavaScript")); // false
public char[ ] toCharArray ( ) ; 将字符串转换成数组
public int indexOf (String str) ; 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int lastIndexOf (String str) ; 查找字符串在当前字符串中最后一次出现的下标索引
// 4. toCharArray(); 返回字符串对应的数组
// 5. indexOf(); 返回字符串首次出现的位置，如果未找到，返回-1。后面如果＋数字表示：从第几个位置开始查找
// 6. lastIndexOf(); 返回字符串最后一次出现的位置
System.out.println(s.toCharArray()); // Java是世界上最好的编程语言,Java就是最简单的,Java最好
System.out.println(Arrays.toString(s.toCharArray())); // [J, a, v, a, 是, 世, 界, 上, 最, 好, 的, 编, 程, 语, 言, ,, J, a, v, a, 就, 是, 最, 简, 单, 的, ,, J, a, v, a, 最, 好]
System.out.println(s.indexOf("Java")); // 0
System.out.println(s.indexOf("Java",4)); // 16
System.out.println(s.lastIndexOf("Java")); // 27
public String trim () ; 去掉字符串前后的空格
public String toUpperCase () ; 将小写转为大写
public boolean endWith (String str) ; 判断字符串是否以str结尾
// 7. trim(); 去掉字符串前后的空格
// 8. toUpperCase(); 把小写转为大写 toLowerCase(); 把大写转为小写
// 9. endsWith(str); 判断是否以str结尾 startsWith(str); 判断是否以str开始
String s2 = " Hello World ! ";
System.out.println(s2.trim()); // Hello World !
System.out.println(s2.toUpperCase()); // HELLO WORLD !
System.out.println(s2.toLowerCase()); // hello world !
String s3 = "hello.java";
System.out.println(s3.endsWith("va")); // true
System.out.println(s3.startsWith("he")); // true
System.out.println(s3.startsWith("ll")); // false
public String replace (char oldChar , char newChar) ; 将旧字符串替换成新字符串
public String[ ] split (String str) ; 根据str做拆分
String s4 = "java is the best language java";
String say = "java is the best programing language,java is good.";
System.out.println(s4.replace("java","php")); // php is the best language php
String[] arr = say.split("[ ,.]+");
System.out.println(arr.length); // 9
for (String string:arr) {
System.out.println(string);
}
/*
java
is
the
best
programing
language
java
is
good
*/
补充
补充俩个方法 equals、compareTo(); 比较大小
String str3 = "hello";
String str4 = "HELLO";
System.out.println(str3.equals(str4)); // false
System.out.println(str3.equalsIgnoreCase(str4)); // true
String a1 = "abc"; // 97 比较ASCII码
String a2 = "ayzawe"; // 120
System.out.println(a1.compareTo(a2)); // -23 比较大小
String a3 = "abc"; // 3
String a4 = "abcdefg"; // 7
System.out.println(a3.compareTo(a4)); // -4 比较长度 3-7
测试
已知 String str = “this is a text”;
将 str 中的单词单独获取出来将 str 中的text替换为 practice在 text 前面插入一个 easy将每个单词的首字母改为大写
public class Test {
public static void main(String[] args) {
String str = "this is a text";
// 1. 将 str 中的单词单独获取出来
String[] arr =str.split(" ");
// System.out.println(arr);
for (String s:arr) {
System.out.println(s);
}
System.out.println("----------------");
// 2. 将 str 中的text替换为 practice
String str2 = str.replace("text","practice");
System.out.println(str2);
System.out.println("----------------");
// 3. 在 text 前面插入一个 easy
String str3 = str.replace("text","easy text");
System.out.println(str3);
System.out.println("----------------");
// 4. 将每个单词的首字母改为大写
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
// 把第一个字符转为大写
char upperfirst = Character.toUpperCase(first);
//System.out.println(upperfirst); // 把所有首字母大写 遍历
String str4 = upperfirst + arr[i].substring(1);
System.out.println(str4);
}
}
}
运行结果：
1.
this
is
a
text
2.
this is a practice
3.
this is a easy text
4.
This
Is
A
Text
可变字符串
StringBuffer： 可变长字符串，JDK 1.0 提供，运行效率慢、线程安全
StringBuilder： 可变长字符串，JDK 5.0 提供，运行效率快、线程不安全
StringBuffer 和 StringBuilder 的使用 与String的区别：
1. 效率比String高
1. 效率比String高
StringBuffer sb1 = new StringBuffer();
StringBuilder sb2 = new StringBuilder();
// 1. append(); 追加
sb1.append("java ");
System.out.println(sb1.toString());
sb1.append("javascript ");
System.out.println(sb1.toString());
sb1.append("c++ ");
System.out.println(sb1.toString());
System.out.println("---------------------");
// 2. insert(); 添加
sb1.insert(0,"我要学");
sb1.insert(sb1.length(),"做一个高级程序员");
System.out.println(sb1.toString());
System.out.println("---------------------");
// 3. replace(); 替换
sb1.replace(0,3,"hello ");
System.out.println(sb1.toString());
System.out.println("---------------------");
// 4. delete(); 删除
sb1.delete(0,3);
System.out.println(sb1.toString());
System.out.println("--------------------------");
// 清空
sb1.delete(0,sb1.length());
System.out.println(sb1.toString());
System.out.println("------------------------------==");
运行结果：
java
java javascript
java javascript c++
---------------------
我要学java javascript c++ 做一个高级程序员
---------------------
hello java javascript c++ 做一个高级程序员
---------------------
lo java javascript c++ 做一个高级程序员
--------------------------
------------------------------==
package OOP.Class_6;
public class Demo03 {
public static void main(String[] args) {
double num1 = 0.9;
double num2 = 0.8;
System.out.println(num1 - num2);//0.09999999999999998
double result = (1.4 - 0.5) / 0.9;
System.out.println(result);//0.9999999999999999
}
}
/*
0.09999999999999998
0.9999999999999999
*/
BigDecimal类
位置： Java.math 包中
作用：精确计算浮点数
创建方法：BigDecimal bd = new BigDecimal (“1.0”);
方法：
BigDecimal add(BigDecimal bd); 加
BigDecimal subtract(BigDecimal bd); 减
BigDecimal multiply(BigDecimal bd); 乘
BigDecimal divide(BigDecimal bd); 除
除法：divide(BigDecimal bd,int scal,RoundingMode mode)
参数：scal: 指定精确到小数点后几位
mode: 指定小数部分的取舍模式，通常采用四舍五入的模式
取值为BigDecimal.ROUND_HALF_UP
下面是代码演示：
public static void main(String[] args) {
// 思考：
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2); // 0.09999999999999998
double result = (1.4-0.5)/0.9;
System.out.println(result); // 0.9999999999999999
// double res = (d1*d2);
// System.out.println(res); // 0.9
// 这些结果都丢失了精度
// 在很多实际应用中需要精确计算，而double是近似值存储，不在符合要求，需要借助 BigDecimal 进行精确计算
// BigDecimal 大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
// 减法 subtract
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1); // 0.1
// 加法 add
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2); // 1.9
// 乘法 multiply
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3); // 0.90
// 除法 divide
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
System.out.println(r4); // 1
// BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"));
// System.out.println(r5); // ArithmeticException
BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_UP);
System.out.println(r5); // 6.67 // " 2,BigDecimal.ROUND_UP " 保留俩位小数 向上取
}
Date类
Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法取代
时间单位：
1秒=1000毫秒1毫秒=1000微秒1微秒=1000纳秒
创建一个今天的此时此刻
// 今天 此时此刻(这是我当时打代码的时间)
Date date1 = new Date();
System.out.println(date1.toString()); // Thu Dec 12 15:06:35 CST 2024
System.out.println(date1.toLocaleString()); // 2024-12-12 15:07:14 toLocaleString 已过时
昨天
// 昨天 此时此刻(今天的时间-一天的毫秒数)
Date date2 = new Date(date1.getTime()-(60*60*24*1000)); // (60秒 * 60分 * 24时 * 1000毫秒)
System.out.println(date2.toLocaleString()); // 2024-12-11 15:09:31
方法：
after与before
boolean b1 = date1.after(date2);
boolean b2 = date1.before(date2);
System.out.println(b1); // true
System.out.println(b2); // false
比较 compareTo();
int d = date1.compareTo(date2);
int d1 = date1.compareTo(date1);
int d2= date2.compareTo(date1);
System.out.println(d); // 1 date1 > date2
System.out.println(d1); // 0 date1 = date2
System.out.println(d2); // -1 date1 < date2
是否相等 equals
boolean b3 = date1.equals(date2);
System.out.println(b3); // false
Calendar类
Calendar提供了获取或设置各种日历字段的方法
构造方法：
protected Calendar(); 由于修饰符是protected ，所以无法直接创建该对象
其他方法：
方法名说明static Calendar getlnstance()使用默认时区和区域获取日历void set (int year,int month,int date,int hourofday,int minute,int secong)设置日历的年，月，日，时，分，秒int get(int field)返回给定日历字段的值，字段比如年月日等void setTime(Date date)用给定的Date设置此日历的时间。Date-CalendarDate getTime()返回一个Date表示此日历的时间。Calendar-Datevoid add(int field,int amount)按照日历的规则，给指定字段添加或减少时间量long getTimeInMillies()毫秒为单位返回该日历的时间值 // 1. 创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString()); // 2024-12-12 15:35:53
System.out.println(calendar.getTimeInMillis()); // 1733988983773 1970年距今毫秒数
获取时间信息
// 2. 获取时间信息
// 获取 年
int year = calendar.get(Calendar.YEAR); // 也可以直接输 1
System.out.println(year); // 2024
// 获取 月 0-11 相当于 1-12
int month = calendar.get(Calendar.MONTH); // 也可以直接输 2
System.out.println(month); // 11 相当于12月
// 获取 日
int date = calendar.get(Calendar.DAY_OF_MONTH); // DATE 或 5
System.out.println(date); // 12
// 获取 时
int hour = calendar.get(Calendar.HOUR_OF_DAY); // HOUR_OF_DAY 是24小时制，HOUR 是12小时制
System.out.println(hour); // 15
// 获取 分
int minute = calendar.get(Calendar.MINUTE);
System.out.println(minute); // 44
// 获取 秒
int secod = calendar.get(Calendar.SECOND);
System.out.println(secod); // 35
System.out.println(year+"年"+(month+1)+"月"+date+"日 "+hour+"时"+minute+"分"+secod+"秒"); // 2024年12月12日 15时51分46秒
修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,11);
System.out.println(calendar2.getTime().toLocaleString()); // 2024-12-11 15:53:53
add方法修改时间
calendar2.add(Calendar.HOUR,-1);
System.out.println(calendar2.getTime().toLocaleString()); // 2024-12-11 14:55:17
补充方法
calendar2.add(Calendar.MONTH,1);
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max); // 31
System.out.println(min); // 1
完整代码：
package com.object.Calendar;
import java.util.Calendar;
public class Demo01 {
public static void main(String[] args) {
// 1. 创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString()); // 2024-12-12 15:35:53
System.out.println(calendar.getTimeInMillis()); // 1733988983773 1970年距今毫秒数
// 2. 获取时间信息
// 获取 年
int year = calendar.get(Calendar.YEAR); // 也可以直接输 1
System.out.println(year); // 2024
// 获取 月 0-11 相当于 1-12
int month = calendar.get(Calendar.MONTH); // 也可以直接输 2
System.out.println(month); // 11 相当于12月
// 获取 日
int date = calendar.get(Calendar.DAY_OF_MONTH); // DATE 或 5
System.out.println(date); // 12
// 获取 时
int hour = calendar.get(Calendar.HOUR_OF_DAY); // HOUR_OF_DAY 是24小时制，HOUR 是12小时制
System.out.println(hour); // 15
// 获取 分
int minute = calendar.get(Calendar.MINUTE);
System.out.println(minute); // 44
// 获取 秒
int secod = calendar.get(Calendar.SECOND);
System.out.println(secod); // 35
System.out.println(year+"年"+(month+1)+"月"+date+"日 "+hour+"时"+minute+"分"+secod+"秒"); // 2024年12月12日 15时51分46秒
// 3. 修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,11);
System.out.println(calendar2.getTime().toLocaleString()); // 2024-12-11 15:53:53
// 4. add方法修改时间
calendar2.add(Calendar.HOUR,-1);
System.out.println(calendar2.getTime().toLocaleString()); // 2024-12-11 14:55:17
// 5. 补充方法
calendar2.add(Calendar.MONTH,1);
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max); // 31
System.out.println(min); // 1
}
}
SimpleDateFormat类
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期 -> 文本）、解析(文本 -> 日期)
常用的时间模式字母
字母日期或时间示例y年2024M月12d日/天12H小时（0-23）19m分钟13s秒59S毫秒357package com.object.SimpleDateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) throws Exception{
// 1. 创建SimpleDateFormat对象 y 年 M 月
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
// 2. 创建Date
Date date = new Date();
// 3. 格式化date(把日期转成字符串)
String str = sdf.format(date);
System.out.println(str); // 2024年12月12日 16:50:18
// 4. 解析 (把字符串转成日期)
Date date2 = sdf.parse("2018年12月12日");
System.out.println(date2); // Wed Dec 12 00:00:00 CST 2018
}
}
System类
System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的
方法名说明static void arraycopy(…);复制数组static long currentTimeMillis();获取当前系统时间，返回的是毫秒值static void gc();建议JVM赶快启动垃圾回收器回收垃圾static void exit(int status);退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm代码验证
package com.object.System;
public class Demo01 {
public static void main(String[] args) {
// arraycopy 数组的复制
// src 原数组
// srcPos 从哪个位置开始复制
// dest 目标数组
// destPos 目标数组的位置
// length 复制的长度
int[] arr = {22,4,69,52,33,95,10,71,43};
int[] dest = new int[9];
System.arraycopy(arr,1,dest,0,5);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+" "); // 4 69 52 33 95 0 0 0 0
}
// currentTimeMillis 从1970 到现在的毫秒数
System.out.print("\n");
System.out.println(System.currentTimeMillis()); // 1733998980366
long start = System.currentTimeMillis();
for (int i = 0; i < 99999; i++) {
for (int j = 0; j < 99999; j++) {
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时："+ (end-start)); // 用时：0 // 我这里设置的数小，电脑性能高的可以往大设
}
}
总结
内部类
在一个类的内部再定义一个完整的类成员内部类、静态内部类、局部内部类、匿名内部类
Object类
所有类的直接或间接父类，可存储任何对象
包装类
基本数据类型所对应的引用数据类型，可以使Object统一所有数据
String类
字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
BigDecimal类
可以精确计算浮点数
Date
特定时间
Calendar
日历
SimpleDateFormat
格式化时间
System
系统类