Java常用类

Object类

基类超类所有类的直接或简介父类位于继承树的最顶层
任何类，如果没显示继承某个类都默认继承 Object类
Object类中所定义的方法是所有对象都具备的方法
Object 类型可以储存任何对象
- 作为参数，可以接受任何对象
- 作为返回值，可以返回任何对象

getclass()方法

后面加重将 class类型反射的时候
返回一个类型
返回引用中储存的实际对象类型

应用：通常用于判断两个引用棕实际储存对象类型是否一致

public final class&lt;?&gt; getClass(){}

代码方便理解

用于判断两个引用棕实际储存对象类型是否一致

先写了一个 Student 类

public class Student{
    private String name;
    private int id;
    //构造方法
    public Student(String name，int id){
        this.name = name;
        this.id = id;
    }
    //get/set
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

接下来是测试类 TestStudent

public class TestStudent{
   public static void main(String[] args){
       Student s1 = new Student("a",18);
       Student s2 = new Student("b",20);
       //接下来就是使用 getClass 进行判断
       Class class1 = s1.getClass();
       Class class2 = s2.getClass();
       if(class1==class2){
           System.out.println("属于同一类型");
       }else
           System.out.println("不属于同一类型");
   }
}

为什么可以判断

**因为 getClass（）方法所返回的是 Class类是一个类对实例对象类进行比较 **

输出：

属于同一类型

hashCode() 方法

返回该对象的哈希码值(int)

public int hashCode(){}

根据对象的地址或者字符串或数字使用 hash算法计算出来的 int类型的数值
一般情况下相同对象返回相同哈希码
可以判断两个对象是否是同一个

这里的类还是使用上面的

public class TestStudent{
    public static void main(String[] args){
        Student s1 = new Student("a",18);
        Student s2 = new Student("b",20);
		Student s3 = s1;
        Student s4 = new Student("a",18);
        System.out.println("s1="+s1.hashCode());
        System.out.println("s2="+s2.hashCode());
        System.out.println("s3="+s3.hashCode());
        System.out.println("s4="+s4.hashCode());
    }
}

输出

s1=1163157884
s2=1956725890
s3=1163157884
s4=356573597

这里可以很清楚的看到 s3 的哈希码值是与 s1相同的

但是 s4 的与 s1的不相同

因为 s3 是直接等于 s1的

但是 s4 虽然实际参数与 s1相同但是 s4 是类重新 new 出来的一个对象所以地址是不一样的

toString()方法

public String toString(){}

返回该对象的字符串表示对象记住是直接对对象进行打印的
可以根据程序需求覆盖该方法如：展示对象的各个属性值

打印的是带包的类的全名称@16进制的哈希值

Inner.demo05.Student@4554617c
Inner.demo05.Student@74a14482

以上分别是 s1 和 s2 的

4554617c 16进制转化 10 进制就是 == 1163157884

地址是一样的

除了这个应用以外呢还有可以根据需求去重写 toString() 方法

例如还是调用Student类

public class Student{
    private String name;
    private int id;
    //构造方法
    public Student(String name，int id){
        this.name = name;
        this.id = id;
    }
    public String toString(){
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

测试

System.out.println(s1.toString());
System.out.println(s2.toString());

输出：

Student{name='aaa', id=20}
Student{name='bbb', id=18}

可以看到改变了返回的方式

equals()方法

public boolean equals(Object obj){}

默认实现是（this == obj），比较两个对象的地址注意这里比较的是地址
可进行覆盖，比较两个对象内容是否相同

在 hashCode() 方法中我们了解到即使属性相同的对象地址也是不一样的所以比较输出出来的还是 false

那我们是否可以通过重写 equals 方法来达到两个类属性相同且类也相同的情况下即使地址不同任然能输出 true

开始思考首先要达到类和属性都相同我们就要设立if语句去判断类和属性
```
if(this.getClass()==obj.getClass()){}
```
在多态中我们学习到父类可以指向子类但是无法使用子类的方法

那这里的 obj 编译类型其实是 Object 类但是运行则为 Student类（多态）

那这里也可以这样写先判断 obj 与 Student 是否存在父子关系（instanceof）
```
if(obj instanceof Student){}
```
还有一个需求就是让obj对象与 Student 对象进行属性的比较

使用的方法是强制转换
```
if(obj instanceof Student){
    Student s = (Student)obj;
    if(this.name.equals(s.name)&amp;&amp;this.id==s.id){
        return true
    }
}
return false;
```
这里有个小疑问后期解决

为什么变化后可以直接调用属性？后面写代码验证一下

这就写完了吗？

还没有这里还需要满足以下以前有的一些内容

比如当 this对象 == obj 的时候（地址也相同的情况）也应该输出 true

当 obj ==null 的时候应该输出为 false

合起来一起写就是：
```
public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if(obj==null){
            return false;
        }
        //if(this.getClass()==obj.getClass()){
        if(obj instanceof Student){
            Student s = (Student)obj;//父类转子类的 强制转换
            //比较属性
            if(this.name.equals(s.name)&amp;&amp;this.id==s.id){
                return true;
            }
        }
        return false;
    }
```

finalize() 方法（Java9 开始被弃用）

当对象被判定为垃圾对象是，由 JVM 自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象为垃圾独享
垃圾回收：由GC销毁垃圾对象啊你个，双方数据储存空间
自动回收机制：JVM内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用 System.gc();通知 JVM 执行垃圾回收

回收没有被引用的对象

重写finalize方法

	@Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被清理");
    }

测试

Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 18);
new Student("ccc",20);
new Student("ddd",20);
System.gc();
System.out.println("回收完成");

输出：

回收完成
ccc对象被清理
ddd对象被清理

可以看到被引用的 s1 s2 并没有被回收

但是没有引用的 ccc ddd 被直接回收了

包装类

栈里存的是基本类型（没有方法）堆里是引用类型
为了让基本类型可以使用方法给基本类型设计了所对应的引用数据类型即为

基本类型的包装类
让基本类型有属性和方法。
Object 可以统一所有的数据，包装类是引用类型所以默认值是 null

| 基本数据类型 | 包装类型 | | ------------ | --------- | | byte | Byte | | short | Short | | int | Integer | | long | Long | | float | Float | | double | Double | | boolean | Boolean | | char | Character |
装箱跟拆箱

类型转换

Number类

`Byte、Integer、Long、Doublie、Short、Float 都是它的子类

方法：

拆箱方法：

引用类型转化为基本类型

| 返回值 | 方法名 | | --------------- | ------------- | | byte | byteValue () | | abstract double | doubleValue() | | abstract float | floatValue() | | abstract int | intValue() | | abstract long | longValue() | | short | shortValue() |

装箱：

这以Integer为例

| 返回值 | 方法名(静态方法) | | -------------- | ---------------- | | static Integer | valueOf(int i) |

代码：
```
public static void main(String[] args){
    int i = 18;
    //完成装箱 将 基本类型i 转变为 引用类型 integer
    Integer integer = Integer.valueOf(i);
}
```
这里有个疑问

Integer.valueOf方法的返回值是一个类这里相当于实例化了一个对象integer既然是对象那为什么输出的时候打印出来不是地址而是具体的值？ ai给出的答案是：当你打印integer时，实际上是调用了Integer类的toString()方法，该方法返回的是封装在Integer对象中的int值的字符串表示形式。

使用 hashCode() 方法再次输出一次也是无法输出出哈希值

Integer类的hashCode()方法被覆盖，以返回封装的int值的哈希码，而不是对象本身的内存地址。

拆箱

代码
```
Integer i3 = Integer.valueOf(i3);
int i = i3.intValue();
//成功将 引用类型 Integer 转变为 基本类型 i
```
这里可以看到是先实例化对象后再进行转换所以类型转换针对的是对象
1. 装箱：把栈的基本类型装到堆里转变成引用类型
2. 拆箱：把堆里的引用类型转变成栈里的基本类型

> 注意：这里以上的代码都是 JDK1.5 之前的装箱拆箱方法 JDK1.5之后 Java提供了自动装箱跟自动拆箱

自动装箱：

int age = 30;
Integer integer = age;

无需再调用方法直接等于默认装箱

自动拆箱：

int age = integer;

基本类型和字符串之间的转换

基本类型转化为字符串
1. new Integer(n)：首先创建了一个 Integer 类的实例。
2. .toString()：然后调用这个实例的 toString 方法，返回封装的 int 值的字符串表示。
3. 创建一个新的 String 对象 s1，并将从 Integer 实例得到的字符串赋值给它。
1. 使用 +号
```
int i =150;
String s1 = i+"";
```
2. 使用 Integer 中的 toString()方法
```
String s2 = Integer.toString(i);
```
  这里引用对象不是Integer的情况下也是直接使用了 Integer的方法
  
  原因：toString()是 Integer的一个静态方法直接调用并将 i直接转变成字符串然后赋值给 s2
  
  小拓展 toString()的重载方法
  
  Integer.toString(int i ,int radix);
  
  把 int i 当 radix 进制返回
```
String s2 = Integer.toString(i,16);//把 i 以 16 进制返回
```
3. 实例化对象后使用 toString()方法
  
  区别于第二种方法这种方法
```
String s1 = new Integer(n).toString();
```
字符串转化为基本类型
```
String str = "150";
```
1. 使用 Integer.parseXXX()方法是一个静态方法可以直接调用
```
int n2 = Integer.parseInt(str);
```
  这里要注意以下如果 str 中存在不是 int 类型的字符
  
  那么就会出现异常
```
Exception in thread "main" java.lang.NumberFormatException: For input string: "150c"
```
  数字格式化异常

boolean ：字符串形式转成 boolean 基本类型

注意：这里有点说法

如果字符串为 "true" 那么就是 true 如果不是 "true" 就都是 "false"

String str = "true";
boolean b1 = Boolean.parseBoolean(str);
System.out.println(b1);

true

String str = "1";
boolean b1 = Boolean.parseBoolean(str);
System.out.println(b1);

false

整数缓冲区

Java预先创建了 256 个常用的整数包装类型对象
再实际应用当中对已创建的对象进行复用

在了解整数缓冲区之前我们需要重新看一下自动装箱的 class文件

在 class 文件中很清楚的看到

自动装箱是通过 Integer.valueOf() 静态方法来实现的

Integer integer = 100;
// Integer integer = Integer.valueOf(100);

那么什么是整数缓冲区？

我们通过一个问题进行引入

Integer integer3 = Integer.valueOf(100);
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3==integer4);//true ?

Integer integer5 = Integer.valueOf(200);
Integer integer6 = Integer.valueOf(200);
System.out.println(integer5==integer6);//false ?

在这里当int i = 100 的时候比较相同输出的是 true

当int i = 200 的时候比较相同输出的是 false

为什么？

我们通过查看 valueOf() 方法的源码了解到

public static Integer valueOf(int i) {
        if (i &gt;= IntegerCache.low &amp;&amp; i &lt;= 			IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache.low = -128;

IntegerCache.high = 127;

IntegerCache.cache[(high - low)+1];

当 i >= -128 && i <= 127时返回值是一个数组内的元素即为 int 类型

除非就是返回一个对象这时候输出的就是一个地址

所以当 i = 200时对比才会输出 false.

而这个 [-128 , 127] 的区间就是整数缓冲区

在区间内返回 int 类型的值

在区间外返回对象

String类

字符串是常量，创建之后不可以改变

这里的不可改变的意思是：

比如我现在写了一行代码
```
String name = "luojinyuan";
```
这里定义了一个String类变量 name

在内存中应该是这样子的：

然后我将变量 name 改变一下
```
name = "罗锦源"；
```
这时候内存会变成这样：

可以看到原来的值 luojinyuan 并没有改变而是新建了一个值

而 luojinyuan没有指向利用 System.gc()就可以清理掉

所以可以看到字符串不会改变但变量可以改变（重新建一个值）
字符串字面值存储在字符串池中 ，可以共享

这时候我们再建一个变量name2等于 罗锦源 内存又该如何？
```
String name2 = "罗锦源"；
```
这时候的内存应该是：

可以看到在栈中新建了一个引用对象地址并且在常量池中都指向相同的对象 罗锦源

所以并不会在常量吃中再新建一个字符串一模一样的常量而是重新建了一个引用地址
另外一种创建字符串的方式
```
String str1 = new String("str");
String str2 = new String("str");
```
这时候栈中会产生相应的地址指向堆中的新建对象然后再指向常量池中的值

我们比较分两种方法比较一下 str1 和 str2
```
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));
```
输出：
```
false
true
```
首先说说为什么输出是 false

因为用 ==比较对象时比较的是对象地址再内存图中可以清楚的看到新建了两个对象分别表示 str1 str2

所以输出 false

那为什么用 equals方法输出就是 true

因为再 String类中 equals被重写了比较的是字符串是否相同

常用方法

返回字符串的长度

public int length();

使用：

String name = "java是世界上最好的语言java ";
System.out.println(name.length());

根据下标获取字符

public char charAt(int index);

使用：

System.out.println(name.charAt(3));
System.out.println(name.charAt(name.length()-1));

注意防止下标越界

判断是否包含某个字符

public boolean contains(String str);

输出：

System.out.println(name.contains("是"));

将字符串转化为数组

public char[] toCharArray();

使用：

char[] a = name.toCharArray();
System.out.println(Arrays.toString(a));

查找 str 首次出现的下标

存在，返回该下标

不存在，返回 -1
```
public int indexOf(String str);
```
使用：
```
System.out.println(name.indexOf("java"))
```
输出:0 输出是首个字符的位置

拓展：

从第 index 个数开始查找str
```
public int indexOf(String str,int index);
```
使用：
```
System.out.println(name.indexOf("java"，4))
```
输出：13

> 从第四个开始查找 java 找到后在字符下标 13的位置

查找字符串再当前字符中最后一次出现的下标索引

public int lastIndexOf(String str);

使用：

System.out.println(name.lastIndexOf("java"));

输出：13

去掉字符串前后的空格
```
public String trim();
```
使用：
```
String name2 = name.trim();
System.out.println(name2);
```
输出：java是世界上最好的语言java

这里要注意输出出来的是字符串

将小写转成大写

public String toUpperCase();

使用：

String name3 = "hello,World";
System.out.println(name3.toUpperCase());

输出：HELLO,WORLD

判断字符串是否以 str 结尾(开头)

public boolean endWith(String str);//结尾
public boolean startWith(String str);//开头

使用：

System.out.println(name3.endWith("World"));
public boolean startWith("Hello")

输出：true true

将旧字符串替换为新字符串
```
public String replace(char oldChar,char newChar);
```
使用：有一个接口的形参可以直接用字符串不只是用字符
```
name.replace("Java"，"php").sout
```
输出：php是世界上最好的语言php
根据str做拆分
```
public String[] split(String str);
```
使用
```
String say = "java is te best propraming language,java xiang";
String[] s = say.spilt(" ");
Arrays.toString(s).sout
```
输出：[java, is, te, best, propraming, language,java, xiang]

拓展

比如可以看到上面的 s替换的时候 ,跟前面的连在一起了我想将,也隔开

可以这样写
```
String[] s = say.spilt("[ ,]");
```
在[]里面写入一个空格和 , 意思是遇到空格或 ,的时候进行拆分

如果是双空格也拆分的话

可以在 []后面加上一个 +号
```
String[] s = say.spilt("[ ,]+");
```
equals 和 compareTo 两种比较大小的方法

首先声明一点

两者的返回值不同

equals 的返回值是 boolean

compareTo 的返回值是 int
```
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equalsIgnoreCase(s2));
```
equalsIgnoreCase() 这个方法可以让 equlas在比较的时候忽略大小写
```
String s3 = "abc";
String s4 = "xyz";
String s5 = "abcxyz";
System.out.println(s3.compareTo(s4));
```
这个代码其实是 做减法

s3 首字母在字符表中的位置比如上面代码中的 a 97

减去

s4 首字母在字符表中的位置比如上面代码中的 x 120

输出：-23

加入首字母相同那么就比较下一位以此类推

特殊情况：
```
System.out.println(s3.compareTo(s5));
```
这里前面都一样但是 s3 没有了 s5 还有

这里就不比较在字符表中的值了

这里比较长度

所以输出的是 3-6

输出：-3
- compareTo
- equals
截取字符
```
public String substring(int beginIndex,int endIndex)
```
针对字符串截取字符
```
String name = "luojinyuan";
name.substring(1);
```
从下标是 1 的字符开始截取字符串到最后

省略了后面的参数 endIndex 的意思是截取到最后一个的字符下标可以自定义截取默认为最后一个

输出：uojinyuan

可变长字符串

这两是类不是方法

StringBuffer:可变长字符串，JDK1.0提供，相对StringBuffer运行效率慢，线程安全

StringBuilder:可变长字符串，JDK5.0提供，运行效率块，线程不安全，单线程建议用这个

这两个类与 String 的区别

代码验证运行效率

String

long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i &lt; 99999; i++) {
	string+=i;
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时"+(end-start));

输出：用时20272

StringBuffer

long start = System.currentTimeMillis();
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i &lt; 99999; i++) {
	stringBuffer.append(i);
}
System.out.println(stringBuffer);
long end = System.currentTimeMillis();
System.out.println("用时"+(end-start));

输出：用时16

使用方法：

首先使用类的方法先实例化类

StringBuffer sb = new StringBuffer();

append();追加字符

sb,append("java是 世界上最好的语言");
System.out.println(sb.toString());

insert();在某个位置添加字符

sb.insert(0,"你好 Java，");//在 下标0 的位置添加
System.out.println(sb.toString());

replace();替换
```
sb.replace(0,7,"Hello java");
System.out.println(sb.toString());
```
这里要注意这里的区间是 [0,7) 含头不含尾
delete();删除
```
sb.delete(0,6);
System.out.println(sb.toString());
```
这里要注意这里的区间是 [0,6) 含头不含尾

这里拓展一个清空可变字符串的办法
```
sb.delete(0,sb.length());
System.out.println(sb.toString());
```
还是用 delete(); 进行清空

效率比 String 高
比 String 节省内存

BigDecimal

引入：

public static void main(String[] args) {
        double d1 = 1.0 ;
        double d2 = 0.9 ;
        System.out.println(d1-d2);
    }
}

输出：0.09999999999999998

不等于 0.1

因为 double 有精度问题存储的值不一定是 1.0 可能是 0.99999999999

这里引入一个类

BigDecimal 可以对浮点数进行精准的运算

前面也说过这个类用于银行等地方的运算

方法

浮点数的运算

还是那句话使用类前先实例化

BigDecimal b1 = new BigDecima("1.0");//这里注意以下 要用字符串 字符串最为精确
BigDecimal b2 = new BigDecima("0.9");

加法add();

BigDecimal r1 = b1.add(b2);
System.out.println(r1);

减法subtract();

BigDecimal r2 = b1.subtract(b2);
System.out.println(r2);

乘法muliply();

BigDecimal r3 = b1.muliply(b2);
System.out.println(r3);

除法divide(); 注意以下异常
```
BigDecimal r3 = b1.muliply(b2);
System.out.println(r3);
```
这是 1.0/0.9 是除不尽的 会报异常
```
Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
```
这里很好解决就是 divide(); 这个方法中有一个精确到小数的参数
```
public BigDecimal divide(BigDecimal bd,int scal,RoundingMode mode){}
```
scal:指定精确到小数点后几位

mode:指定小数部分的取舍模式，经常采用四舍五入如下
```
BigDecimal divide = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);
```
这里的意思是 b1/b2 精确到小数点后两位，BigDecimal.ROUND_HALF_UP 的意思是四舍五入

这样就不会报异常了

列式编程连续运算

BigDecimal r2 = new BigDecimal("1.0")
         		.subtract(new BigDecimal("35"))
         		.add(new BigDecimal("65"))
         		.multiply(new BigDecimal("59"))
         		.divide(new BigDecimal("11"),2,BigDecimal.ROUND_HALF_UP);
System.out.println(r2);

输出：166.27

Date

Date表示瞬间精确到毫秒
现在大部分的方法都被 Calendar
不太全面，国际化问题所以被取代

构造方法无参：

public Date();

创建一个 Date对象当前的时间精确到毫秒

打印

 Date date1 = new Date();
 System.out.println(date1);

直接打印的话格式是这样的

输出：Mon Jun 03 20:31:04 CST 2024

所以一般用这个方法来打印toLocalString();

System.out.println(date1.toLocaleString());

不过呢这个方法已经过时了但是仍然可以使用

上面的是今天的写一个昨天的此时此刻

Date date2 = new Date(date.getTime()-(24*60*60*1000));
System.out.println(date2.toLocaleString());

> getTime();返回的是从 1970年开始到现在的毫秒数

方法

after(); 和before(); 判断时间的先后返回值是布尔值
```
boolean after = date.after(date1);
System.out.println(after);
```
输出:true

date 在 date1 之后

before();同理

compareTo(); 比较时间减法返回值是int

 int i = date.compareTo(date1);
 System.out.println(i);

输出：1

equals(); 比较是否相等返回值是布尔值

boolean equals = date.equals(date1);
System.out.println(equals);

输出：false

Calendar

Calendar 提供了获取或设置各种日历的方法
构造方法
```
protected Calendar();
```
注意这里的修饰符是protected所以无法直接创建对象

方法

静态方法：

获取时间

Calendar calendar = Calendar.getInstance();

打印

我们先看使用 toString();方法打印
```
System.out.println(calendar);
```
输出：

java.util.GregorianCalendar[time=1717418897886,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2024,MONTH=5,WEEK_OF_YEAR=23,WEEK_OF_MONTH=2,DAY_OF_MONTH=3,DAY_OF_YEAR=155,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=8,HOUR_OF_DAY=20,MINUTE=48,SECOND=17,MILLISECOND=886,ZONE_OFFSET=28800000,DST_OFFSET=0]

看不懂

所以不能直接输出

那我们如何打印

我们先使用 getTime(); 方法将它变成Date再使用 toLocalString(); 方法进行打印
```
System.out.println(calendar.getTime().toLocalString());
```
输出：2024-6-3 20:48:17

还有一种是打印毫秒值
```
System.out.println(calendar.;getTimeInMillis());
```
输出：1717418897886

获取时间信息 get();

在 Calendar 类中提供了很多常量

如 YEAR MONDAY MONDAY

int i = calendar.get(Calendar.YEAR);
int i1 = calendar.get(Calendar.MONDAY);
int i2 = calendar.get(Calendar.MONDAY);
int i3 = calendar.get(Calendar.HOUR_OF_DAY);
int i4 = calendar.get(Calendar.MINUTE);
int i5 = calendar.get(Calendar.SECOND);
System.out.println(i+"年"+(i1+1)+"月"+i2+"日"+i3+":"+i4+":"+i5);

输出：2024年6月3日20:48:17

这里有个点就是在 HOUR中有两个

HOUR：12小时

HOUR_OF_DAY：24小时

还有就是

可以看到 MOUTH 月中是从 0 开始的

所以要+1

修改时间 set();

Calendar calendar1 = Calendar.getInstance();
calendar1.set(Calendar.DAY_OF_MONTH,5);
System.out.println(calendar1.getTime().toLocaleString());

输出：2024-6-5 20:59:41

这里是直接将 Calendar.DAY_OF_MONTH 改成了 5

添加 add();

calendar1.add(Calendar.HOUR_OF_DAY,1);
System.out.println(calendar1.getTime().toLocaleString());

输出：2024-6-5 21:59:41

这里是将Calendar.HOUR_OF_DAY 增加了 1

获取时间的最大值或最小值比如一个月中的最后一天 getActualMaximum(); getActualMinimum();
```
int actualMaximum = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(actualMaximum);
```
输出：30

SimpleDateFormat

以语言环境有关的方式格式化和解析日期的具体类
进行格式化（日期---->文本）
解析（文本---->日期）
常用时间模式字母

| 字母 | 日期或时间 | 实例 | | ---- | ------------------- | ---- | | y | 年 | 2019 | | M | 年中月份 | 08 | | d | 月中天数 | 10 | | H | 1天中小时数（0-23） | 22 | | m | 分钟 | 16 | | s | 秒 | 59 | | S | 毫秒 | 367 |

实例化的时候定义时间格式

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");

然后定义一个 Date 类试试

Date date = new Date();

格式化 Date 将日期变成字符串 format(); 返回值是String类型

String format = sdf.format(date);
System.out.println(format);

输出：2024年06月03日 21：18：32

解析将字符串转化为日期返回值是Date类型

Date parse =sdf.parse("2024年06月03日 20：10：06");
System.out.println(parse.toLocaleString());

输出：2024-6-3 20:10:06

如果这里输入的字符串不是上面 sdf 所定义的格式就会异常

解析失败异常

Exception in thread "main" java.text.ParseException: Unparseable date: "202406月03日 20：10：06"

System

系统类，主要用于获取系统的属性数据和其他操作，构造方法私有
大部分方法是静态方法所以不需要实例化直接调用

方法

复制数组

static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

src:原数组要复制哪个数组

srcPos:从哪个位置开始复制 0

dest:目标数组

destPos:目标数组的位置从哪里开始放复制的东西

length:复制的长度

int[] arr ={20,18,15,8,35,26,45,30};
int[] dest = new int[arr.length];
System.arraycopy(arr,0,dest,0,arr.length);

获取当前系统时间，返回毫秒值

static long currentTimeMillis();

之前在可变长字符串里面使用过这个来测试运行的时间

long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i &lt; 99999; i++) {
    string+=i;
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时"+(end-start));

start是记录还未运行下面程序时的一个时间

end 是记录运行结束后的一个时间

差值就是用时

建议JVM赶快启动垃圾回收器回收垃圾
```
static void gc();
```
这里具体看 Object类中的 finalize()方法
退出jvm，如果参数是 0 表示正常突出非0则是异常推出 jvm
```
static void exit(int status);
```
退出Jvm虚拟机以后后续的程序将不再运行
```
System.exit(0);
```