JavaSE：常用类

进击的嗷呜兔兔

已于 2022-05-14 15:21:44 修改

阅读量80

点赞数

分类专栏： # JavaSE 文章标签： java

于 2022-05-14 15:21:33 首次发布

本文链接：https://blog.csdn.net/qq_59463944/article/details/124741132

版权

JavaSE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

JavaSE：常用类

前言

即使再小的帆也能远航

一、内部类与常用类概述

内部类
Object类
Object类常用方法
包装类
String类
BigDecimal类

二、内部类

1. 内部类分类

成员内部类：
1. 不能定义静态成员，但可以定义静态常量
2. 创建内部类时对象时，必须依赖外部类对象
3. 当内部类与外部类的属性重名，会优先访问内部类属性，要是还想要访问外部类的属性时，用 Outer.this.属性访问

//外部类
public class Outer {
    //实例变量
    private int id = 9;
    private static int age = 3;

    //成员内部类（各种权限修饰符都可以）
    class Inner{
        private int phone = 110;
        //private static int price = 20;    //非静态不能定义静态的
        private static final int pname = 007;   //可以定义常量
        private int id = 99;   //与外部类重名的属性

        public void show(int id){
            //打印外部类的属性
            System.out.println(id);
            System.out.println(this.id);
            System.out.println(Outer.this.id);
            System.out.println(age);
            //打印内部类的属性
            System.out.println(phone);
            //System.out.println(price);
            System.out.println(pname);
        }
    }
}

public class Test {
    public static void main(String[] args) {
//        //第一种方法
//        Outer outer = new Outer();
//        Outer.Inner inner = outer.new Inner();

        //第二种
        Outer.Inner inner = new Outer().new Inner();
        inner.show(999);
    }
}

静态内部类：
1. static修饰的
2. 可直接被创建或通过类名访问

//外部类
public class Outer {
    //实例变量
    private int id = 9;
    private static int age = 3;

    //静态内部类（各种权限修饰符都可以）
    static class Inner{
        private int phone = 110;
        private static int price = 20;
        private static final int pname = 007;   //可以定义常量
        private int id = 99;   //与外部类重名的属性

        public void show(int id){
            //打印外部类的属性
            System.out.println(id);
            System.out.println(this.id);
            //System.out.println(Outer.this.id);    //此时无法直接通过Outer.this调用
            Outer outer = new Outer();
            System.out.println(outer.id);
            System.out.println(age);
            //打印内部类的属性
            System.out.println(phone);
            System.out.println(price);
            System.out.println(pname);
        }
    }
}

public class Test {
    public static void main(String[] args) {

        Outer.Inner inner = new Outer.Inner();
        inner.show(999);
    }
}

局部内部类：
1. 定义在外部类方法内的内部类
2. 作用范围和创建对象仅限于当前方法
3. 局部内部类内的变量必为final型

//外部类
public class Outer {
    //实例变量
    private int id = 9;
    private static int age = 3;

    public void show(){
        //局部内部类（各种权限修饰符都可以）
        final int id = 66;  //不写final，也默认是final常量

        class Inner{
            private int phone = 110;
            //private static int price = 20;
            private static final int pname = 007;   //可以定义常量
            private int id = 999;   //与外部类重名的属性

            public void show(int id){   //传进来一个局部变量
                Inner inner = new Inner();
                say();
                //打印外部类的属性
                System.out.println(id);
                System.out.println(this.id);
                System.out.println(Outer.this.id);
                System.out.println(age);
                //打印内部类的属性
                System.out.println(phone);
                //System.out.println(price);
                System.out.println(pname);
            }

            public void say(){
                System.out.println("say hi");;
            }
        }
        new Inner().show(9999);
        System.out.println(id);
    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

匿名内部类：
1. 没有类名的局部内部类（一切特征都和局部内部类相同）
2. 必须继承一个父类或者实现一个接口
3. 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象

public class Test {
    public static void main(String[] args) {
        UserService userService = new UserService() {
            int id = 99;
            @Override
            public void show(int id) {
                System.out.println(id);
                System.out.println(this.id);
                System.out.println(UserService.id);
            }
        };
        userService.show(999);

        Father father = new Father() {
            @Override
            public void say() {
                System.out.println("Father");
            }
        };
        father.say();
    }
}

//接口
public interface UserService {
    //private int id = 9;
    int id = 9;
    public void show(int id);
}

public abstract class Father {
    public abstract void say();
}

2. 内部类概念

概念：在一个类的内部再定义一个完整的类。
特点：
1. 内部类可编译生成独立的字节码文件
  即也会生成class文件（explorer内可查）
2. 内部类可直接访问外部类的私有成员，而不破坏封装
3. 可为外部类提供必要的内部功能组件

静态内部类不能访问外部类的属性方法，所以android开发过程中可以优化handler
其他内部类可以访问外部类，是因为持有外部类的引用。

成员内部类：
　　成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，默认情况下访问的是成员内部类的方法。访问外部类方法：
　　　　外部类.this.成员变量
　　　　外部类.this.成员方法
　　外部类想访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问，内部类的创建依赖外部类：
　　　　Outter outter = new Outter();
　　　　Outter.Inner inner = outter.new Inner();
　　和外部类不同，内部类可以用private，protected，public修饰，内部类有点类似外部类变量的味道。public 都可以访问，private修饰时只能在外部类的内部访问，protected修饰只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。
静态内部类，添加了static 关键字，不依赖与外部类。
局部内部类：
方法内部定义，作用于在方法内部，不能用访问修饰符修饰。
匿名内部类，没有构造函数，主要用于事件绑定，回调函数设置。

内部原理说明：

public class OuterClass {
	public static void main(String args) {
	}

	class Inner1 {		
	//成员内部类
	}
	
	static class Inner2{
	//静态内部类
	}
	
	public  void getInner() {
		class Inner3{
			//局部内部类
		}
	}
	
	接口与匿名内部类的实现
	public void getEvent() {
		setClick(new Event() {
			@Override
			public void onClick() {
			}
		});
	}
	
	interface Event{
		void onClick();
	}
	
	public void setClick(Event event) {}
	
}

编译之后生成：
在这里插入图片描述

利用javap -p 命令进行分析。
// javap 是 Java class文件分解器，可以反编译，也可以查看java编译器生成的字节码。用于分解class文件。

以上内部类相关为CSDN博主「lidongxiu0714」的原创文章，原文链接：https://blog.csdn.net/u010126792/article/details/82840563

三、Object类

1.Object类概述

超类、基类、祖先类
所有类都直接或间接继承这个类
Object类中定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

2.getClass（）方法

public final Class getClass(){}
返回引用中存储的的实际对象类型
应用：通常用于判断俩个引用中实际存储对象类型是否一致

3. hashCode（）方法

public int hashCode（）{}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同哈希码

4. toString（）方法

public String toString(){}
返回该对象的字符串表示
可以根据程序需求覆盖该方法

5. equals（）方法

public boolean equals(Object obj){}
默认实现为（this==obj），比较两个对象地址是否相同
可进行覆盖，比较俩个对象的内容是否相同

6. finalize（）方法

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

public class Test {
    public static void main(String[] args) {
        Student aaa = new Student("aaa", 3);
        Student bbb = new Student("bbb", 20);
        //getClass方法
        Class a = aaa.getClass();
        Class b = bbb.getClass();
        System.out.println(a==b);
        System.out.println("========");
        //hashCode方法
        System.out.println(aaa.hashCode());
        System.out.println(bbb.hashCode());
        System.out.println(aaa.hashCode()==bbb.hashCode());
        Student ccc = aaa;  //引用
        System.out.println(ccc.hashCode());
        System.out.println(ccc.hashCode()==aaa.hashCode());
        System.out.println("========");
        //toString方法（覆盖）
        System.out.println(aaa.toString());
        System.out.println("========");
        //equals方法（比较地址），可重写
        System.out.println(aaa.equals(bbb));
        System.out.println(aaa.equals(ccc));
        Student qia = new Student("qia", 21);
        Student han = new Student("han", 20);
        System.out.println(qia.equals(han));
        System.out.println("========");
        //finalize方法
        System.gc();//此时前面的对象未被回收
        new Student("s1",1);
        System.gc();
    }
}

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        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 o) {
        //1. 判断俩个对象是否是同一个引用，如果是那肯定相等
        if (this == o) return true;

        //2. 判断o是否为空以及是否是同一个类型，传进来空或者不是同一个类型的那肯定不相等
        if (o == null || getClass() != o.getClass()) return false;

        //3. 判断对象是否相等
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    protected void finalize() throws Throwable {
        //原方法体为空，为判断是否执行添加了输出语句
        System.out.println(this.name+"对象被回收了");
    }
}

四、包装类

1. 包装类概述

基本数据类型所对应的引用数据类型
Object可统一所有数据（数据被包装成类对象后，这样数据就可以使用一些方法了），包装类的默认值是null

2. 类型转换与装箱、拆箱

包装类提供不同类型间的转换方式
- Number父类中提供的6个共性方法
  （所有的包装类都是Number抽象类的子类）
- parseXXX()静态方法
- valueOf()静态方法
- 需保证类型兼容，否则抛出NumberFormatException异常

public class Demo01 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        //装箱
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num2);
        System.out.println(integer1);
        System.out.println(integer2);
        System.out.println(integer1.getClass());    //装箱后为引用对象类型，就可以调用一些方法

        System.out.println("========");

        //拆箱
        Integer integer3 = new Integer(100);
        int num3 = integer3.intValue();
        System.out.println(num3);

        System.out.println("========");

        //JDK1.5之后，提供自动装箱和拆箱
        int age = 3;
        //自动装箱
        Integer integer4 = age;
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println(age2);
    }
}

public class Demo02 {
    public static void main(String[] args) {
        //基本类型与字符串之间转换
        //1 基本类型转成字符串
        int n1 = 3;
        String s1 = n1 + "";    //int转成String
        System.out.println(s1);
        String s2 = Integer.toString(n1,2);    //括号内radix为几进制
        System.out.println(s2);
        System.out.println(Integer.toBinaryString(n1));     //二进制
        System.out.println(Integer.toHexString(16));    //十六进制  15：0123456789abcdef
        System.out.println(Integer.toOctalString(8));
        //2 字符串转成基本类型
        String str = "150";
        //使用Integer.parseXXX()
        int i = Integer.parseInt(str);
        System.out.println(i);
        //注意：boolean字符串形式转成基本类型，只分true和非true,非true即false
        String str1 = "true";
        boolean b1 = Boolean.parseBoolean(str1);
        System.out.println(b1);
        String str2 = "tu";
        boolean b2 = Boolean.parseBoolean(str2);
        System.out.println(b2);

    }
}

3. Integer缓冲区（整数缓冲区）

Java预先创建了256个常用的整数包装类型对象，即
整数缓存区：valueOf的缓存范围在-128~127，超出范围九false了
在实际应用当中，对已创建的对象进行复用

public class Demo03 {
    public static void main(String[] args) {
        //面试题

        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        //两个都是基本数据类型转成引用对象类型（开辟了内存）后再比较，比较的就是地址
        //有new就说明在堆中产生了新对象
        System.out.println(integer1==integer2);

        //转回基本数据类型后再比较，比较的就是内容了
        int i1 = integer1;
        int i2 = integer2;
        System.out.println(i1==i2);

        Integer integer3 = 100;
        Integer integer4 = 100;
        System.out.println(integer3==integer4);
        //会相等，自动装箱并没有new，而使用的valueOf方法.
        //整数缓存区：valueOf的缓存范围在-128~127，超出范围九false了
        //Integer integer3 = Integer.valueOf(100);
//        public static Integer valueOf(int i) {
//            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
                                //IntegerCache：整数缓冲区
//                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
//            return new Integer(i);    //如果超出范围就new一个Integer
//        }

        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5==integer6);
        //此处false是因为内存溢出了，超过了int的最大范围
    }
}

五、String类

1. String概述(不可变字符串)

字符串是常量，创建之后不可改变
字符串 字面值 存储在字符串池中，可以共享
（栈里面存的是基本数据类型，堆里面存的是对象）
（JDK1.7，字符串常量池被移到了堆中）
变量名只是引用，存的是地址，当重新赋值后，引用指向另外的一个内存空间，所以地址发生了变化
- String s = “Hello”; //产生一个对象，字符串池中存储
- String s = new String(“Hello”); //产生两个对象，堆、栈各存储一个
String类重写了父类的equals方法

public class Demo04 {
    //mspaint打开画图工具
    public static void main(String[] args) {

        String name= "hello";
        System.out.println(name.hashCode());
        name = "zhangsan";
        System.out.println(name.hashCode());
        //name是引用，存的是地址，当重新赋值后，引用指向另外的一个内存空间，所以地址发生了变化

        String kuangtu = "zhangsan";
        System.out.println(kuangtu.hashCode());
        System.out.println(kuangtu==name);
    }
}

2. String常用方法

public int length()：返回字符串的长度
public char charAt(int index)：根据下标获取字符
public boolean contains(String str)：判断当前字符串中是否包含str

public class Demo01 {
    public static void main(String[] args) {
        String content = "Java 是世界上最好的编程语言";
        System.out.println(content.length());   //16,空格也是一个字符
        System.out.println(content.charAt(0));
        System.out.println(content.charAt(8));
        System.out.println(content.contains("java"));
        System.out.println(content.contains("php"));
    }
}

public char[] toCharArray()：将字符串转换成数组
public int indexOf(String str)：查找str首次出现的下标，存在，返回该下标；不存在，则返回-1
public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引

public class Demo02 {
    public static void main(String[] args) {
        String content = "Java 是世界上最好的编程语言 a";
        char[] chars = content.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        System.out.println("========");
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println("========");
        System.out.println(content.indexOf("a"));
        System.out.println(content.lastIndexOf("a"));
        System.out.println(content.indexOf("a",2));
    }
}

public String trim()：去掉字符串前后的空格
public String toUpperCase()：将小写转成大写
public boolean endWith(String str)：判断字符串是否以str结尾

public class Demo03 {
    public static void main(String[] args) {
        String content = "    Java 是世界上最好的编程语言 a    ";
        System.out.println(content);
        System.out.println(content.length());
        System.out.println("====去掉前后空格后====");
        //去掉前后空格后
        System.out.println(content.trim());
        System.out.println(content.trim().length());
        System.out.println("====大小写====");
        System.out.println(content.toUpperCase());
        System.out.println(content.toLowerCase());
        System.out.println("========");
        System.out.println(content.endsWith("a"));
        System.out.println(content.endsWith(" "));
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));
    }
}

public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
public String[] split(String str)：根据str做拆分

public class Demo04 {
    public static void main(String[] args) {
        String content = "Java 是世界上最好的编程语言 a";
        System.out.println(content.replace("Java","php"));
        System.out.println("========");
        String say = "java is the best programing language";
        String[] s = say.split(" ");
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
    }
}

比较大小：
equals
compareTo

public class Demo05 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));
        String s3 = new String("hello");
        System.out.println(s1.equals(s3));
        System.out.println(s1==s3);
        System.out.println("========");

        //compareTo逐位比较
        System.out.println(s1.compareTo(s2));
        System.out.println(s1.compareTo(s3));
        String s4 = new String("hellO");
        System.out.println(s1.compareTo(s4));
        String s5 = new String("hell");
        System.out.println(s1.compareTo(s5));
        String s6 = new String("he");
        System.out.println(s1.compareTo(s6));
    }
}

3. String案例演示

已知String str = “this is a text”;

将str中的单词单独获取出来
将str中的text替换为practice
在text前面插入一个easy
将每个单词的首字母改为大写

/*
已知String str = "this is a text";
1. 将str中的单词单独获取出来
2. 将str中的text替换为practice
3. 在text前面插入一个easy
4. 将每个单词的首字母改为大写
 */
public class Demo06 {
    public static void main(String[] args) {
        String str = "this is a text";
        String[] arr=str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }
        System.out.println("========");
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
        System.out.println("========");
        String str3 = str.replace("text","easy text");
        System.out.println(str3);
        System.out.println("========");
        for (int i = 0; i < arr.length; i++) {
            char c = arr[i].charAt(0);
            //c = Character.toUpperCase(c);
            if(c>='a' || c<='z') c-=32;
            String news = c + arr[i].substring(1);
            System.out.print(news+" ");
        }
    }
}

4. 可变字符串（String增强类）

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全

/*
StringBuffer和StringBuilder的使用
和String的区别：
1. 效率更高
2. 节省内存
 */
public class Demo07 {
    public static void main(String[] args) {

        //StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //功能一样，更推荐使用StringBuilder

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

        //2. insert 添加
        sb.insert(0,"say:");    //0位前添加
        System.out.println(sb.toString());

        //3. replace
        sb.replace(0,3,"Hello World!"); //0-2位替换（含头不含尾）
        System.out.println(sb.toString());

        //4. delete
        sb.delete(5,12);    //含头不含尾
        System.out.println(sb);

        //5. reverse 翻转
        sb.reverse();
        System.out.println(sb);

        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

/**
 * 验证StringBuilder效率高于String
 */
public class Demo08 {
    public static void main(String[] args) {
//        long start = System.currentTimeMillis();
//        String string = "";
//        for (int i = 0; i < 99999; i++) {
//            string+=i;
//        }
//        long end = System.currentTimeMillis();
//        System.out.println("用时"+(end-start));   //用时18210  即用时18秒
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            sb.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start));   //用时16
    }
}

六、其他类

1. BigDecimal类

浮点数是近似值存储
BigDecimal:
- 位置：java.math包中
- 作用：精确计算浮点数

import java.math.BigDecimal;

public class Demo01 {
    public static void main(String[] args) {

        double result = (1.4-0.5)/0.9;
        System.out.println(result);

        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);

        //用字符串传入能最精确
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //subtract减法
        System.out.println(bd1.subtract(bd2));
        //add加法
        System.out.println(bd1.add(bd2));
        //multiply乘法
        System.out.println(bd1.multiply(bd2));
        //除法
        BigDecimal r = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"),2);   //保留两位小数
        System.out.println(r);
        //四舍五入
        BigDecimal r2 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r2);
        BigDecimal r3 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r3);
        //进行除法运算时，如果不能准确地计算出结果时，需要指定保留的位数和取舍方式
    }
}

2. Date类

Date表示特定的瞬间，精确到毫秒
Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位
- 1秒=1000毫秒

import java.util.Date;

public class Demo02 {
    public static void main(String[] args) {
        //今天
        Date date1 = new Date();
        System.out.println(date1);
        //昨天
        Date date2 = new Date(date1.getTime() - (24 * 60 * 60 * 1000));
        System.out.println(date2);
        //方法
        System.out.println(date1.after(date2));
        System.out.println(date1.before(date2));
        System.out.println(date1.compareTo(date2));
        System.out.println(date1.equals(date2));
    }
}

3. Calendar类

Calendar提供了获取或设置各种日历字段的方法
Calendar类的构造方法是protected的，所以无法直接创建该对象

import java.util.Calendar;

public class Demo03 {
    public static void main(String[] args) {
        //1. 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime());
        System.out.println(calendar.getTimeInMillis()); //1970以来的毫秒值  1652505224574
        //2. 获取时间信息
        //获取年...
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day_of_year = calendar.get(Calendar.DAY_OF_YEAR);
        int day_of_month = calendar.get(Calendar.DAY_OF_MONTH);
        int day_of_week = calendar.get(Calendar.DAY_OF_WEEK);
        int hour_24 = calendar.get(Calendar.HOUR_OF_DAY);
        int hour_12 = calendar.get(Calendar.HOUR);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
//        System.out.println("year:"+year);
//        System.out.println("month:"+month);
//        System.out.println("day_of_year:"+day_of_year);
//        System.out.println("day_of_month:"+day_of_month);
//        System.out.println("day_of_week:"+day_of_week);
//        System.out.println("hour_12:"+hour_12);
//        System.out.println("hour_24:"+hour_24);
//        System.out.println("minute:"+minute);
//        System.out.println("second"+second);
        //跳转时间  跳转到 月日2
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,2);
        System.out.println(calendar2.getTime());
        //add方法修改时间
        calendar2.add(Calendar.DAY_OF_MONTH,10);
        System.out.println(calendar2.getTime());
        //补充方法
        int maximum = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int minimum = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(maximum);
        System.out.println(minimum);
    }
}
java

4. SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期->文本）、解析（文本->日期）
常用的时间模式字母
- 年月日时分秒毫秒
- y M d H(24) h(12) m s S

import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo04 {
    public static void main(String[] args) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yy-MM-dd");
        //格式化（日期->文本）
        Date date = new Date();
        String s = sdf.format(date);
        System.out.println(s);
        //解析（文本->日期）
        Date date2 = sdf.parse("02-09-11");
        System.out.println(date2);
    }
}

5. System类

System系统类，主要用于获取系统的属性数据和其他操作
构造方法是私有的

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //1.
        //arraycopy:数组的复制
        //src:源数组
        //srcPos:从哪个位置开始复制
        //dest:目标数组
        //destPos:目标数组的位置
        //length:复制的长度
        //System.arraycopy(src,srcPos,dest,destPos,length);
        int[] arr = {9,5,1,7,3,8,2,6};
        int[] dest = new int[arr.length];
        //System.arraycopy(arr,0,dest,0,arr.length);
        System.arraycopy(arr,4,dest,4,arr.length-4);
        for (int i = 0; i < dest.length; i++) {
            System.out.print(dest[i]+" ");
        }
        System.out.println();
//        System.out.println("========");
//        int[] copy = Arrays.copyOf(arr,9);
//        for (int i : copy) {
//            System.out.println(i);
//        }
//        System.out.println("========");
//        int[] range = Arrays.copyOfRange(arr, 4, 10);
//        for (int i : range) {
//            System.out.println(i);
//        }
        //2.
        //currentTimeMillis获取时间（可用于计算时间）
        long start = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < 9999; i++) {
            str+=i;
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
        //3.
        //System.gc();    //回收匿名对象
        new Student("s1",21);
        Student s2 = new Student("s2", 20);
        System.gc();    //回收匿名对象
        //4.
        //退出JVM
        System.exit(-1);
        System.out.println("程序结束了...");
        
    }
}
/*
总结一下exit()方法：
语法：
       System.exit(参数);
状态：
       1.正常终止当前运行的Java虚拟机：System.exit(0)
       2.异常终止当前运行的Java虚拟机：System.exit(非零的int型参数)
       虽然exit()方法的参数不同，所以终止的状态也不同，但是效果确实相同的（关闭当前虚拟机），为什么还要有正常终止和异常终止两种状态呢？因为根据使用的场景不同，需要我们自己判断该方法应进行哪种状态的终止。
 */

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        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 o) {
        //1. 判断俩个对象是否是同一个引用，如果是那肯定相等
        if (this == o) return true;

        //2. 判断o是否为空以及是否是同一个类型，传进来空或者不是同一个类型的那肯定不相等
        if (o == null || getClass() != o.getClass()) return false;

        //3. 判断对象是否相等
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    protected void finalize() throws Throwable {
        //原方法体为空，为判断是否执行添加了输出语句
        System.out.println(this.name+"对象被回收了");
    }
}