Java_常用类

内部类

概念：在一个类的内部再定义一个完整的类。

特点：

• 编译之后可生成独立的字节码文件。
• 内部类可直接访问外部类的私有成员，而不破坏封装。
• 可为外部类提供必要的内部功能组件。

成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

  • Outer outer = new Outer();
    

  • Outer.Inner inner = outer.new Inner();
    

• 当外部类、内部类存在重名属性时吗，会优先访问内部类属性。如果内部类属性和外部类属性名字相同，调用外部类属性要加上Outer.this

• 成员内部类不能定义静态成员，但可以包含静态常量。

成员内部类代码：

package com.jack.classes;

//外部类
public class Outer01 {
    private String name = "张三";
    private  int age = 20;

    //内部类
    class Inner{
        private String address = "北京";
        private String phone = "110";
        //属性和外部类属性名字相同
        private String name = "李四";

        //方法
        public void show(){
            //打印外部类属性，如果内部类属性和外部类属性名字相同，调用外部类属性要加上Outer.this
            System.out.println(Outer01.this.name);
            System.out.println(Outer01.this.age);
            //打印内部类属性
            System.out.println(this.address);
            System.out.println(this.phone);
        }
    }
}

测试代码：

package com.jack.classes;

public class TestOuter01 {
    public static void main(String[] args) {
        //1.创建外部类对象
//        Outer outer = new Outer();
        //2.创建内部类对象
//        Outer.Inner inner = outer.new Inner();

        //一步到位
        Outer01.Inner inner = new Outer01().new Inner();

        inner.show();
    }
}

静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 普通的外部类不能加static。

静态内部类代码：

package com.jack.classes;

public class Outer02 {
    private String name = "xxx";
    private int age = 18;

    //静态内部类,级别和外部类相同
    static class Inner{
        private String address = "上海";
        private String phone = "111";
        //静态成员
        private static int count = 1000;

        public void show(){
            //调用外部类的属性
            //1.先创建一个外部类对象
            Outer02 outer02 = new Outer02();
            //2.再来调用外部类对象的属性
            System.out.println(outer02.name);
            System.out.println(outer02.age);
            //调用静态内部类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}

测试代码：

package com.jack.classes;

public class TestOuter02 {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer02.Inner inner = new Outer02.Inner();
        inner.show();
    }
}

局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类中不能定义静态变量，但可以定义静态常量（final）。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为 final（JDK1.8默认加上final）。

局部内部类代码：

package com.jack.classes;

public class Outer03 {
    private String name = "刘德华";
    private int age = 35;

    public void show(){
        //定义局部变量
        String address = "深圳";

        //局部内部类:注意不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "15588888888";
            private String email = "123456@163.com";

            public void show2(){
                //访问外部类的属性
                System.out.println(Outer03.this.name);
                System.out.println(Outer03.this.age);
                //访问内部类属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //访问局部变量
                System.out.println(address);
            }
        }
        Inner inner = new Inner();
        inner.show2();
    }
}

测试代码：

package com.jack.classes;

public class TestOuter03 {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.show();
    }
}

匿名内部类

• 没有类名的局部内部类(一切特征都与局部内部类相同)。
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
• 优点：减少代码量。
• 缺点：可读性较差。

接口代码：

package com.jack.classes;

public interface Usb {
    void service();
}

匿名内部类测试代码：

package com.jack.classes;

public class TestUsb {
    public static void main(String[] args) {
        //使用匿名内部类(相当于隐藏的创建了一个局部内部类)
        Usb usb = new Usb() {
            @Override
            public void service() {
                System.out.println("连接电脑成功，键盘开始工作...");
            }
        };
        usb.service();
    }
}

从out文件可以看到，匿名内部类文件即TestUsb$1.class，相当于隐藏的创建了一个局部内部类。

Object类

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

getClass() 方法

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

hashCode() 方法

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

toString() 方法

• public String toString(){}
• 返回该对象的字符串表示(表现形式)。
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值。

equals() 方法

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

equals() 方法覆盖步骤

• 比较两个引用是否指向同一个对象。
• 判断obj是否为null。
• 判断两个引用指向的实际对象类型是否一致。
• 强制类型转换。
• 依次比较各个属性值是否相同。

finalize() 方法

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

类代码：

package com.jack.classes.object_class;

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 name + ":" + age;
    }

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

    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否是同一个引用
        if (this == obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj == null){
            return false;
        }
        //3.判断是否是同一个类型
//        if (this.getClass() == obj.getClass()){
//            return true;
//        }
        //instanceof 判断是否是某种类型
        if (obj instanceof Student){
            //4.强制类型转换
            Student s = (Student) obj;
            //5.比较熟悉
            if (this.name.equals(s.getName()) && this.age == s.getAge()){
                return true;
            }
        }

        return false;


    }
}

测试代码：

package com.jack.classes.object_class;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",23);
        //1.getClass方法
        //判断s1和s2是不是同一个类型
        System.out.println("-----------------getClass---------------------");
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }

        //2.hashCode方法
        System.out.println("-----------------hashCode---------------------");
        System.out.println(s1.hashCode());//460141958
        System.out.println(s2.hashCode());//1163157884
        Student s3 = s1;
        System.out.println(s3.hashCode());//460141958

        //3.toString方法
        System.out.println("-----------------toString---------------------");
        System.out.println(s1.toString());//com.jack.classes.object_class.Student@1b6d3586
        System.out.println(s2.toString());//com.jack.classes.object_class.Student@4554617c

        //4.equals方法
        //判断两个对象是否相等
        System.out.println("-----------------equals---------------------");
        System.out.println(s1.equals(s2));//false

        Student s4 = new Student("王五",30);
        Student s5 = new Student("王五",30);
        System.out.println(s4.equals(s5));
    }
}

package com.jack.classes.object_class;

public class TestStudent02 {
    public static void main(String[] args) {
//        Student s1 = new Student("aaa",20);
//        Student s2 = new Student("bbb",20);
//        Student s3 = new Student("ccc",20);
//        Student s4 = new Student("ddd",20);
//        Student s5 = new Student("eee",20);
        new Student("aaa",20);
        new Student("bbb",20);
        new Student("ccc",20);
        new Student("ddd",20);
        new Student("eee",20);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

包装类

• 基本数据类型所对应的引用数据类型。
• Object可统一所有数据，包装类的默认值是null。

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

类型转换与装箱、拆箱

• 8种包装类提供不同类型间的转换方式

  • Number父类中提供的6个共性方法。
  • parseXXX() 静态方法。
  • valueOf() 静态方法。

• 注意：需保证类型兼容，否则抛出NumberFormatExcetion异常。

package com.jack.classes.packageing_class;

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);//18
        System.out.println(integer2);//18

        //类型转换：拆箱，引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");//拆箱
        System.out.println(num2);//100
        //以上为JDK1.5之前，自动装箱和拆箱的方法

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

        System.out.println("------------------------------------------");
        //基本类型和字符串之间转换
        //1.基本类型转成字符串
        int n1 = 100;
        //1.1使用+号
        String s1 = n1 + "";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1, 2);//将n1转换成二进制，radix为进制
        System.out.println(s1);//100
        System.out.println(s2);//100
        System.out.println(s3);//1100100

        //2.字符串转成基本类型
        String str = "150";
        //使用Integer.parseXXX()
        int n2 = Integer.parseInt(str);
        System.out.println(n2);//150

        //boolean字符串形式转成基本类型。"true"-->true, 非"true"-->false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);//true
    }
}

整数缓冲区

• Java预先创建了256个常用的整数包装类型对象。（-128 ~ 127）
• 在实际应用当中，对已创建的对象进行复用。

源码：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)//low=-128,high=127
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

测试代码：

package com.jack.classes.packageing_class;

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false

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

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

    }
}

String

• 字符串是常量，创建之后不可改变。
• 字符串字面值存储在字符串池中，可以共享。
• String s = " Hello"；产生一个对象，字符串池中存储。
• String s = new String(“Hello”)；//产生两个对象，堆、池各存储一个。

常用方法

• public int length()：返回字符串的长度。
• public char charAt(int index)：根据下标获取字符。
• public boolean contains(String str)：判断当前字符串中是否包含str。
• public char[ ] toCharArray()：将字符串转换成数组。
• public int indexOf(String str)：查找str首次出现的下标，存在，则返回下标；不存在，则返回-1。
• public last lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引。
• public String trim()：去掉字符串前后的空格。
• public String toUpperCase()：将小写转成大写。
• public String toLowerCase()：将大写转成小写。
• public boolean endWith(String str)：判断字符串是否以str结尾。
• public boolean startWith(String str)：判断字符串是否以str开头。
• public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串。
• public String[ ] split(String str)：根据str做拆分。
• public boolean equals(String str)：比较大小，只比较值。
• public boolean equalsIgnoreCase(String str)：忽略大小写的比较，只比较值。
• public int compareTo(String str)：根据ASCII代码的位置数字大小或者字符串长度进行比较，返回值为int，详情见测试代码。

package com.jack.classes.packaging_class;

import java.util.Arrays;
import java.util.Locale;

public class Demo03 {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中
        name = "zhangsan";//"zhangsan"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开一个空间
        String name2 = "zhangsan";//name2会在字符串池中寻找有没有“zhangsan”，有则赋值给name2，此时name和name2地址都指向字符串池中的“zhangsan”对象，地址相同。
        System.out.println(name == name2);//true

        //演示字符串的另一种创建方式：new String()
        String str = new String("Java");
        String str2 = new String("Java");
        System.out.println(str == str2);//false，“==”比的是地址
        System.out.println(str.equals(str2));//true,因为equals比的是数据，而不是地址

        //字符串方法的使用
        String content = "java是世界上最好的java编程语言,java真香";

        //1.length()：返回字符串的长度
        System.out.println(content.length());//26

        //2.charAt(int index)：根据下标获取字符
        System.out.println(content.charAt(content.length() - 1));//香

        //3.contains(String str)：判断当前字符串中是否包含str
        System.out.println(content.contains("java"));//true
        System.out.println(content.contains("php"));//false

        //4.toCharArray()：将字符串转换成数组
        System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 世, 界, 上, 最, 好, 的, j, a, v, a, 编, 程, 语, 言, ,, j, a, v, a, 真, 香]

        //5.indexOf(String str)：查找str首次出现的下标，存在，则返回下标；不存在，则返回-1
        System.out.println(content.indexOf("java"));//0
        System.out.println(content.indexOf("java",4));//11

        //6.lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引
        System.out.println(content.lastIndexOf("java"));//20

        String content2 = "    hello world    ";

        //7.trim()：去掉字符串前后的空格
        System.out.println(content2.trim());//hello world

        //8. toUpperCase()：将小写转成大写; toLowerCase()：将大写转成小写
        System.out.println(content2.toUpperCase());//"    HELLO WORLD    "
        System.out.println(content2.toLowerCase());//"    hello world    "

        //9.endWith(String str)：判断字符串是否以str结尾； startWith(String str)：判断字符串是否以str开头
        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));//true
        System.out.println(filename.startsWith("hello"));//true

        //10.replace(char oldChar,char newChar)：将旧字符串替换成新字符串
        System.out.println(content.replace("java","python"));

        //11.split(String str)：根据str做拆分
        String say = "java is the best     programing language,java wang";
        String[] arr = say.split(" ");
        System.out.println(arr.length);//11
        for (String string : arr) {
            System.out.println(string);
            /*
            java
            is
            the
            best




            programing
            language,java
            wang
             */
        }
        String[] arr2 = say.split("[ ,]+");//用[]将分隔符设置为“ ”和“，”两种，+号代表多个
        System.out.println(arr2.length);//8
        for (String string : arr2) {
            System.out.println(string);
            /*
            java
            is
            the
            best
            programing
            language
            java
            wang
             */
        }

        //补充两个方法equals()、compareTo();比较大小
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true,    equalsIgnoreCase()表示忽略大小写的比较

        String s3 = "abc";//a->97
        String s4 = "xyz";//x->120
        System.out.println(s3.compareTo(s4));//-23,    只比较第一个字符，即a和z，a-z = 97 - 120 = -23

        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6));//-3,这种情况下不比大小的，比长度，s5.length = 3,s6.length = 6,3 - 6 = -3; 如果两个一样则为0
    }
}

可变字符串

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

方法简介代码：

package com.jack.classes.packaging_class;

/**
 * StringBuffer和StringBuilder的使用
 * 和String区别：（1）效率比String高（2）比String节省内存
 */

public class Demo04 {
    public static void main(String[] args) {
//        StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //1.append();追加
        sb.append("java世界第一");
        System.out.println(sb.toString());//java世界第一
        sb.append("java真香");
        System.out.println(sb.toString());//java世界第一java真香

        //2.insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());//我在最前面java世界第一java真香

        //3.replace();替换
        sb.replace(0,4,"hello");
        System.out.println(sb.toString());

        //4.delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());//面java世界第一java真香
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());//0

    }
}

效率测试代码:：

package com.jack.classes.packaging_class;

/**
 * 验证StringBuilder效率高于StringBuffer
 */

public class Demo05 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
//        String string = "";
//        for (int i = 0; i < 99999; i++) {
//            string += i;
//        }
//        System.out.println(string);//用时：29657
//        StringBuilder sb = new StringBuilder();
//        for (int i = 0; i < 99999; i++) {
//            sb.append(i);
//        }
//        System.out.println(sb);//用时:28
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            sb.append(i);
        }
        System.out.println(sb);//用时:31
        long end = System.currentTimeMillis();
        System.out.println("用时："+ (end - start));
    }
}

BigDecimal

• 很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，需要借助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 scale,RoundingMode mode)

• 参数scale：指定精确到小数点后几位。

• 参数mode：

  • 指定小数部分的取舍模式，通常采用四舍五入的模式。
  • 取值为 BigDecimal.ROUND_UP。

测试代码：

package com.jack.classes.packaging_class;

import java.math.BigDecimal;

public class Demo06 {
    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

        //BigDecimal,大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");//一定要用字符串
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);//0.1
        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);//1.9
        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);//0.90
        //除法
        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"), 2, BigDecimal.ROUND_UP);//BigDecimal.ROUND_UP代表四舍五入
        System.out.println(r5);//3.34


    }
}

Date

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

测试代码：

package com.jack.classes.packaging_class;

import java.util.Date;

public class Demo07 {
    public static void main(String[] args) {
        //1.创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());//Sat Jul 17 15:37:23 CST 2021
        System.out.println(date1.toLocaleString());//2021-7-17 15:37:23    此方法已过时
        //昨天
        Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000));
        System.out.println(date2.toLocaleString());//2021-7-16 15:37:23

        //2.方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //3.比较compareTo()
        int d = date1.compareTo(date2);//1
//        int d = date2.compareTo(date1);//-1
//        int d = date2.compareTo(date2);//0
        System.out.println(d);
        //比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);//false
    }
}

Calendar

• Calendar提供了获取或设置各种日历字段的方法。

• 构造方法

  • protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。

• 其他方法

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month,int date,int hourOfDay, int minute)	设置日历的年、月、日、时、分、秒。
int get(int field)	返回给定日历字段的值。字段比如年、月、日等
void setTime(Date date)	用给定的Date设置此日历的时间。Date-Calendar
Date getTime()	返回一个Date表示此日历的时间。 Calendar-Date
void add(int field,int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillis()	毫秒为单位返回该日历的时间值

测试代码：

package com.jack.classes.packaging_class;

import java.util.Calendar;

public class Demo08 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//2021-7-17 15:55:17

        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月0-11
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//Date
        //获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR 12小时 HOUR_OF_DAY 24小时
        //获取分钟
        int minute = calendar.get(Calendar.MINUTE);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);//2021年7月17日16:2:11

        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar2.getTime().toLocaleString());//2021-7-5 16:05:25

        //4.add方法修改时间
        calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toLocaleString());//2021-7-5 15:05:25

        //5.补充方法
        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	年	2021
M	年中月份	07
d	月中天数	10
H	1天中小时数（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	367

测试代码：

package com.jack.classes.packaging_class;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo09 {
    public static void main(String[] args) throws Exception{
        //1.创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2.创建Date
        Date date = new Date();
        //格式化date（把日期转换成字符串）
        String str = sdf.format(date);
        System.out.println(str);//2021/07/17
        //解析（把字符串转换成日期）
        Date date2 = sdf.parse("1990/05/01");
        System.out.println(date2);//Tue May 01 00:00:00 CDT 1990
    }
}

System类

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

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status);	退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm。

测试代码：

package com.jack.classes.packaging_class;

public class Demo10 {
    public static void main(String[] args) {
        //arraycopy:数组的复制
        //System.arraycopy(src,srcPos,dest,destPos,length);
        //src:源数组
        //srcPos:从哪个位置开始复制，默认0
        //dest:目标数组
        //destPos:目标数组的位置
        //length:复制的长度
        int[] arr = {20,18,15,8,35,26,45,90};
        int[] dest = new int[8];
        System.arraycopy(arr,4,dest,4,4);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
            /*
            0
            0
            0
            0
            35
            26
            45
            90
             */
        }

        long start = System.currentTimeMillis();//1626511288278
        for (int i = -99999999; i < 999999999; i++) {
            for (int j = -99999999; j < 999999999; j++) {
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));//用时：5

        //System.gc();告诉垃圾回收器回收垃圾
        new Student("aaa", 20);
        new Student("bbb", 20);
        new Student("ccc", 20);

        System.gc();
        /*
        回收了ccc    20
        回收了bbb    20
        回收了aaa    20
         */

        //退出jvm
        System.exit(0);
        System.out.println("程序结束了...");//这行代码没有被执行，因为上一行代码已经退出了jvm

    }
}