Java中的内部类和常用类用法解读

目录

• 内部类和常用类
• 内部类
• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类
• 常用类
• Object类
• 包装类
• String类
• StringBuffer和StringBuilder
• BigDecimal
• Date类
• Calendar类
• SimpleDateFormat类
• System类
• 总结

内部类和常用类

内部类

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

 package com.object.demo01;
 ​
 public class Body {
     private String name;
     class Header{
         //内部类也会生成一个class文件 编译之后可以生成独立的字节码文件
         //内部类可为外部类提供必要的功能组件
         public void show() {    
             System.out.println(name);   //内部类可以直接访问外部类的私有成员，而不破坏封装
         }
     }
 }

成员内部类

package com.object.demo02;
 ​
 //外部类
 public class Outer {
     //实例变量
     private String name = "张三";
     private int age = 18;
 ​
     //内部类 与实例变量、实例方法同级别的类
     class Inner {
         private String address = "北京";
         private String phone = "110";
 ​
         private String name =  "李四"; 
         
         //private static int scores = 86; 内部类不能定义静态成员
         private static final int scores = 86; //但是可以定义静态常量
         //方法
         public void show() {
             //打印外部类的属性
             System.out.println(name);   //内部类属性和外部类属性名字相同，优先打印内部类
             System.out.println(Outer.this.name);    
             System.out.println(age);    //可以在age前加上Outer.this这样更清晰 可读性
             //打印内部类的属性
             System.out.println(address);        //同理可以加上this.
             System.out.println(phone);          //同理加上this.
         }
     }
 }

 package com.object.demo02;
 ​
 public class TestOuter {
     public static void main(String[] args) {
         //内部类的创建必须依赖外部类对象
 //        //1.先创建一个外部类对象
 //        Outer outer = new Outer();
 //        //2.创建一个内部类对象
 //        Outer.Inner inner = outer.new Inner();
 ​
         //一步到位
         Outer.Inner inner = new Outer().new Inner();
 ​
         inner.show();
     }
 }

静态内部类

不依赖内部类对象，可直接创建或通过类名访问，可声明静态成员

 package com.object.demo03;
 ​
 //外部类
 public class Outer {
     private String name = "xxx";
     private int age = 18;
 ​
     //静态内部类：和外部类相同
     static class Inner {    //只有内部类才可以用static修饰，正常的类不能用static
         private String address = "上海";
         private String phone = "110";
 ​
         //静态成员
         private static int count = 10000;
 ​
         public void show() {
             //如何调用外部类的属性呢
             //System.out.println(name); 不对
             Outer outer = new Outer();
             System.out.println(outer.name);
             System.out.println(outer.age);
             //调用静态内部类的属性和方法
             System.out.println(address);
             System.out.println(phone);
             //调用静态内部类的静态属性
             System.out.println(Inner.count);
 ​
         }
     }
 }

package com.object.demo03;
 ​
 public class Test {
     public static void main(String[] args) {
         //静态内部类相当于一个外部类
         //直接创建静态内部类对象
         Outer.Inner inner  =new Outer.Inner();  //没有new Outer();
         //调用方法
         inner.show();
     }
 }

​

局部内部类

定义在外部类方法中，作用范围仅限于当前方法

package com.object.demo04;
 ​
 public class Outer {
     private String name = "张三";
     private int age = 18;
 ​
     public void show() {
         //定义局部变量
         final String address = "深圳";    //局部内部类访问外部类当前方法的局部变量时，因无法保障变量的声明周期与自身相同，变量修饰必须为final
 ​
         //局部内部类：注意不能加任何访问修饰符
         class Inner {   //在堆里 不会消失
             private String phone = "110";
             private String email = "111@qq.com";
 ​
            // private static int count = 0; 局部内部类里不能有静态属性，同样可以有静态常量
             
             public void show2() {
                 //访问外部类的属性 但是show被static修饰就不能访问
                 //因为static 和类一起加载 外部类属性还没加载出来
                 System.out.println(name);   //可以加上Outer.this. 可读性强
                 System.out.println(age);
                 //访问内部类属性
                 System.out.println(phone);  //可以加上this.
                 System.out.println(email);  //同上
                 
                 //访问局部变量 jdk1.7要求是常量 jdk1.8自动加上final
                 System.out.println(address);
             }
         }
         
         //创建内部类对象
         Inner inner = new Inner();
         inner.show2();
     }
 }

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

匿名内部类

• 没有类名的局部内部类
• 必javascript须继承一个父类或者实现一个接口
• 优点：减少代码量
• 缺点：可读性较差

package com.object.demo05;
 ​
 //接口
 public interface USB {
     //定义一个服务方法
     void service();
 }

package com.object.demo05;

public class Mouse implements USB {
    @Override
    public void service() {
        System.out.println("连接成功，鼠标开始工作");

    }
}

package com.object.demo05;

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


        //创建接口类型变量
        //USB usb = new Mouse();
        //usb.service();

        //局部内部类
    class Fan implements USB {


        @Override
        public void service() {
            System.out.println("连接成功，风扇开始工作");
        }
    }
        USB usb = new Fan();
        usb.service();

    }
}

这是使用局部内部类。局部内部类只使用一次，可以用匿名内部类进行优化->

 package com.object.demo05;
 ​
 public class Test {
     public static void main(String[] args) {
 ​
         //使用匿名内部类创建对象(相当于创建了一个局部内部类)
         // USB usb = new USB();  报错-接口不能实例化
         USB usb = new USB() {
             @Override
             public void service() {
                 System.out.println("连接成功，风扇开始工作");
             }
         };
         usb.service();
 ​
         //使用匿名内部类优化
 ​
     }
 }

常用类

Object类

在Java.lang包下

超类，所有对象都继承这个类的方法

getClass()方法

返回class类型

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

 package com.object.demo06;
 ​
 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;
     }
 }

package com.object.demo06;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 22);
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();

        if (class1 == class2) {
            System.out.println("s1 is the same class");
        } else {
            System.out.println("s1 is not the same class");
        }
    }
}

hashCode()方法

返回int类型

哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

以上节课的代码为例

package com.object.demo06;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 22);
        
        //hashCode方法
        System.out.println(s1.hashCode());	//开辟第一块空间 
        System.out.println(s2.hashCode());	//开辟第二块空间
        Student s3 = s1;
        System.out.println(s3.hashCode());	//将第一块空间赋予它
		//1、3相等，1、2不等
    }
}

toString()方法

返回值类型String

可以根据程序需求重写该方法

package com.object.demo06;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 22);
        
        //3.toString
        System.out.println(s1.toString());	
        System.out.println(s2.toString());
    }
}

得到的是@+16进制哈希值

想要看到具体的属性就要对toString进行重写

package com.object.demo06;

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;
    }
	//快捷键alt+ins
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

equals()方法

返回布尔类型

package com.object.demo06;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 22);
        
        //4.equals方法：判断两个对象是否相等
        System.out.println("-----------------------------------");
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明", 17);
        System.out.println(s4.equals(s5));  //虽然两者的属性相同，但是分别开辟了一个内存空间 false

    }
}

要让属性相同返回true就要对equals进行重写

 @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;
 //        }
         if (obj instanceof Student) {    //instanceof判断对象是否是某种类型
             //4.强制类型转换
             Student s = (Student) obj;
             //5.比较属性
             if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                 return true;
             }
         }
         return false;
     }

finalize()方法

该方法一般情况下，程序员不会调用

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

@Override
     protected void finalize() throws Throwable {
         System.out.println(this.name +"对象被回收了");
     } //对finalize方法进行重写

 package com.object.demo06;
 ​
 public class Test2 {
     public static void main(String[] args) {
         Student s1 = new Student("aaa", 20);
         new Student("bbb", 20);
 ​
         //回收垃圾
         System.gc();
         System.out.println("回收垃圾"); //aaa正常，bbb被回收
     }
 }

包装类

基本数据所对应的引用数据类型

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

类型转换与装箱拆箱

• 栈里面的对象拿到堆里面：装箱
• 堆里面的对象拿到栈里面：拆箱

package com.object.demo07;

public class Test {
    public static void main(String[] args) {
        //类型转换：装箱：基本类型转成引用类型的过程
        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以后，提供自动装箱和拆箱
        int age = 18;
        //自动装箱
        Integer integer4 =age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 =  integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);


    }
}

基本类型转换

package com.object.demo07;

public class Test {
    public static void main(String[] args) {
        
        //基本类型转成字符串
        int n1 = 15;
        //1.使用+号
        String s1 = n1 + "";
        //2.使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1,16);    //toString重载方法，将它转成指定进制
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

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

        //boolean字符串形式转成基本类型，"true"-->true,只要这个字符串不是true就是false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

    }
}

整数缓冲区

Java预先创建了256个常用的整数包装类型对象Integer

我们接下来从一个程序来加深这句话的理解

package com.object.demo07;


public class Test2 {
    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 integer3 = Integer.valueOf(100) TNIzcvJna后续同理
        Integer integer4 = Integer.valueOf(100); //自动装箱
        System.out.println(integer3 == integer4);
        //integer3,integer4都是引用类型，答案也是false吗？ 结果是true

        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5 == integer6);
        //这三行和上面三行几乎没差别 结果却相反 是false
    }
}

自动装箱是使用Integer.valueOf()

问题就出在这个方法，ctrl+鼠标看valueOf()源码

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

low= -128,high = 127;

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

100在-128~127 返回cache[] 数组

数组在缓冲区中有256个位置，将100这个值取地址给integer3和integer4,两者地址相同，所以返回true

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

200不在-128~127 return new Integer(i); 和Integer1,2一样，在堆内存开辟新空间

String类

String概述

• 字符串是常量，创建之后不消失
• 字符串字面量存储在字符串池中，可以共享

package com.object.demo07;

public class Test3 {
    public static void main(String[] args) {
        String name = "hello";  //"hello" 存储在常量池中
        System.out.println(name.hashCode());    //假如hashcode是x
        name = "zhangsan";    //"zhangsan"赋值给name 给字符串赋值时，并没有在原字符串上修改数据，而是重新开辟一块空间
        String name2 = "zhangsan";

        System.out.println(name.hashCode());    //hashcode是y “zhangsan”字符串常量可以共享
        System.out.println(name2.hashCode());   //hashcode是y
        
    }
}

String常用方法

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

package com.object.demo07;

public class Test3 {
    public static void main(String[] args) {
        //字符串方法的使用
        //length();返回字符串的长度
        //charAt(int index);返回某个位置的字符
        //contains(String str);判断是否是某个子字符串

        String content = "java是世界上最好的编程语言";
        System.out.println(content.length());   //15
        System.out.println(content.charAt(0));  //第一个字符
        System.out.println(content.charAt(content.length()-1)); //最后一个字符
        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):查找字符串在当前字符串中最后一次出现的下标

package com.object.demo07;

import java.util.Arrays;

public class Test3 {
    public static void main(String[] args) {
        
        //字符串方法的使用
        //toCharArray();返回字符串对应的数组
        //indexOf();返回子字符串出现的位置
        //lastIndexOf();返回字符串最后一次出现的位置
		String content = "java是世界上最好的Java编程语言,java真香";

        System.out.println(content.toCharArray());
        System.out.println(Arrays.toString(content.toCharArray())); //把这个数组当字符串输出出来
        System.out.println(content.indexOf("java"));    //0
        System.out.println(content.indexOf("java", 4)); //找第二个java,从角标为4开始找，但是最终结果还是以第一个字符为0
        System.out.println(content.lastIndexOf("java"));    //找最后一个java


    }
}

• public String trim():去掉字符串前后的空格
• public String toUpperCase():将小写转成大写
• public String toLowerCase():将大写转成小写
• public boolean endsWith(String str):判断字符串是否以str结尾
• public boolean startsWith(String str):判断字符串是否以str开头

package com.object.demo07;

import java.util.Arrays;

public class Test3 {
    public static void main(String[] args) {
      
        //字符串方法的使用
        //trim();去掉字符串前后的空格
        //toUpperCase(); 把小写转成大写
        //toLowerCase(); 把大写转成小写
        //endsWith(str); 判断是否以str结尾，startsWith(str);判断是否以str开头

        String content2 = " hello   World   ";
        System.out.println(content2.trim());
        System.out.println(content2.toUpperCase());
        System.out.println(content2.toLowerCase());
        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[] split(String str):根据str做拆分

package com.object.demo07;

import java.util.Arrays;

public class Test3 {
    public static void main(String[] args) {
        
        //字符串方法的使用
        //replace(char old, char new);用新的字符串替换旧的字符串
     javascript   //split();对字符串进行拆分
        System.out.println(content.replace("java", "php"));
        String say = "java is the best programming language";
        String[] arr = say.split(" ");
        System.out.println(arr.length); //6,拆分成6个字符串
        for (String s : arr) {
            System.out.println(s);
        }
        String say1 = "java is the best programming language,java xiang";
       //想要把字符串空格和逗号去掉来分割
        String[] arr1 = say1.split("[ ,]");
        for (String s : arr1) {
            System.out.println(s);
        }
        String say2 = "java is the best      programming language,java xiang";
        //想要多个空格也能去除
        String[] arr2 = say2.split("[ ,]+");
        for (String s : arr2) {
            System.out.println(s);
        }
        System.out.println("--------------------------");
        //补充两个方法equals; compareTo();
        String s1 = "hello";
        String s2 = "Hello";
        System.out.println(s1.equals(s2));  //false
        System.out.println(s1.equalsIgnoreCase(s2));    //忽视大小写 true

        String s3 = "abc";  //a是97
        String s4 = "xyz";  //x是120
        System.out.println(s3.compareTo(s4));   //两个字符串首个字符的ASCII码值相减 -23,首个相同就减下一个以此类推

        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6));   //s5刚好在s6里面的前面，则比较长度 -3
    }
}

案例分析

package com.object.demo07;

//案例演示
//已知String str =  "this is a text";
/*
* 将str中的单词单独获取出来
* 将str中的text替换为practice
* 在text前面插入一个easy
* 将每个单词的首字母改为大写

* */
public class Test4 {
    public static void main(String[] args) {
        String str = "this is a text";
        //将str中的单词单独获取出来
        String[] arr = str.split(" ");
        for(String str1 : arr) {
            System.out.println(str1);
        }

        //将str中的text替换为practice
       String s1 = str.replace("text", "practice");

        //在text前面插入一个easy
        String s2 = str.replace("text", "easy text");

        //将每个单词的首字母改为大写
for(int i = 0; i < arr.length; i++) {
    char first = arr[i].charAt(0);
    char upperFirst = Character.toUpperCase(first);
    String s3 = upperFirst+arr[i].substring(1);


}

    }

}

StringBuffer和StringBuilder

• StringBuffer:可变长字符串，运行效率慢，线程安全 多线程用
• StringBuilder:可变长字符串，运行效率快，线程不安全 单线程用

效率比String高，比String更节省内存

StringBuffer和StringBuilder方法通用，常见方法如下

package com.object.demo08;

public class Demo01 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //1.append(); 追加
        sb.append("Java世界第一");
        System.out.println(sb.toString());
        sb.append("Java真香");
        System.out.println(sb.toString());
        //2.insert(); 添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());
        //3.replace();
        sb.replace(0, 4, "Hello");  //含头不含尾 面字还留着
        System.out.println(sb.toString());
        //4.delete(); 删除
        sb.delete(0, 6);
        System.out.println(sb.toString());
        //5.reverse(); 翻转
        sb.reverse();
        System.out.println(sb.toString());
        //清空
        sb.delete(0, sb.length());
        System.out.println(sb.length());

    }
}

package com.object.demo08;

public class Demo02 {
    public static void main(String[] args) {
        //验证效率StringBuilder高于String
        long startTime = System.currentTimeMillis();    //开始时间
        String string = "";
        for (int i = 0; i < 999; i++) {
            string += i;    //字符串的拼接
        }
       
        System.out.println(string.toString());
        long endTime = System.currentTimeMillis();
        System.out.println("用时"+ (endTime - startTime));

    }
}

package com.object.demo08;

public class Demo02 {
    public static void main(String[] args) {
        //验证效率StringBuilder高于String
        long startTime = System.currentTimeMillis();    //开始时间
        
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < 999; i++) {
            builder.append(i);
        }
        System.out.println(builder.toString());
        long endTime = System.currentTimeMillis();
        System.out.println("用时"+ (endTime - startTime));
    }
}

BigDecimal

• 位置：java.math包中
• 作用：精确计算浮点数
• 创建方法：BigDecimal bd = new BigDecimal("1.0");

package com.object.demo08;

import java.math.BigDecimal;

public class Demo03 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1 - d2);
        //输出结果0.0999999999...
        //很多实际应用中需要精确计算，而double是近似值存储，需要借助BigDecimal
        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);


        //BigDecimal,大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0"); //要用字符串
        BigDecimal bd2 = new BigDecimal("0.9");
        System.out.println(bd1.subtract(bd2));  //减法
        System.out.println(bd1.add(bd2));   //加法
        System.out.println(bd1.multiply(bd2));  //乘法

        BigDecimal result1 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(result1);

        //除不尽情况
        //BigDecimal r = new BigDecimal("10").divide(new BigDecimal("3"));    //出现异常
        BigDecimal r = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);   //保留两位小数，四舍五入
        System.out.println(r);


    }

}

Date类

Date表示特定的瞬间，精确到毫秒。Date中大部分方法已经被Calendar类中方法取代

package com.object.demo08;

import java.util.Date;

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

        //1.创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());   //打印当前时间 用空格连接
        System.out.println(date1.toLocaleString()); //打印当前时间 用-连接，已过时

        //昨天
        Date date2 = new Date(date1.getTime() - 24 * 60 * 60 * 1000);
        System.out.println(date2.toString());
        //方法 after before
       boolean b1= date1.after(date2);
        System.out.println(b1);
        boolean b2= date1.before(date2);
        System.out.println(b2);

        //比较 compareTo();
        int d = date1.compareTo(date2); //比较两者的毫秒值 毫秒值相减 正数返回1，负数返回-1
        System.out.println(d);

        //比较数相等 equals
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
        
    }
}

Calendar类

package com.object.demo08;

import java.util.Calendar;

public class Demo05 {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar calendar = Calendar.getInstance(); //Calendar是protected不能直接new
        System.out.println(calendar.toString());    //打印的东西特别多，不是我们想要看到的形式
        System.out.println(calendar.getTime().toString());  //把calendar转成date类
        System.out.println(calendar.getTimeInMillis());
        //获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR); //也可以把Calendarandroid.YEAR写成1，这样的话可读性差
        System.out.println(year);
        //获取月 从0-11，0代表一月
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  //24小时制
        int hour2 = calendar.get(Calendar.HOUR);    //12小时制
        System.out.println(hour);
        System.out.println(hour2);
        //获取分钟
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);
        //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(second);

        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 5);    //修改日
        System.out.println(calendar2.getTime().toLocaleString());

        //add修改时间
        calendar2.add(Calendar.HOUR, 1);
        System.out.println(calendar2.getTime().toLocaleString());
        calendar2.add(Calendar.HOUR, -1);   //减少时间
        System.out.println(calendar2.getTime().toLocaleString());

        //补充
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);  //获取月的最大天
        System.out.println(max);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);  //获取月的最小天
        System.out.println(min);
    }
}

SimpleDateFormat类

将日期转成特定格式

 package com.object.demo08;
 ​
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 ​
 public class Demo06 {
     public static void main(String[] args) throws ParseException {
         //创建SimpleDateFormat对象 y年 M月 d日 H时 m分 s秒
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 ​
         //创建一个Date
         Date date = new Date();
 ​
         //格式化Date 把日期转化成字符串
         System.out.println(sdf.format(date));
 ​
         //解析 把字符串转成日期
         Date date2 = sdf.parse("2025-5-11 12:00:00");   //格式和上面的pattern一样
         System.out.println(date2);
 ​
     }
 }

​

System类

主要用于互殴去系统的属性数据和其他操作，构造方法私有

 package com.object.demo08;
 ​
 public class Student {
     private String name;
     private int age;
 ​
     public Student(String name, int age) {
         this.name = name;
         this.age = age;
     }
 ​
     public Student() {
 ​
     }
 ​
     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
     protected void finalize() throws Throwable {
         System.out.println("回收了"+name+" "+age);
     }
 }

 package com.object.demo08;
 ​
 public class Demo07 {
     public static void main(String[] args) {
         //不用创建System对象
         //arraycopy(); 参数：src,srcPos(指的是src的下标),dest,destPos,length
         int[] arr = {1,2,3,4,5,6,7,8,9};
         int[] dest = new int[8];
         System.arraycopy(arr,0,dest,0,8);
         for (int i = 0; i < dest.length; i++) {
             System.out.println(dest[i]);
         }
 ​
         //currentTimeMillis(),获取当前系统时间，返回毫秒值 可以用来计算代码的执行时间
         System.out.println(System.currentTimeMillis());
 ​
         long start = System.currentTimeMillis();
         for (int i = 0; i < 9999; i++) {
             for (int j = 0; j < 9999; j++) {
                 int result = i+j;
             }
         }
         long end = System.currentTimeMillis();
         System.out.println("用时"+(end - start));
 ​
 ​
         //System.gc(); 回收垃圾
 ​
         new Student("aaa", 19);
         new Student("bbb", 20);
         Student s3 = new Student("ccc", 21);
 ​
         System.gc();
 ​
         //exit(); 退出jvm
         System.exit(0);
         System.out.println("程序结束"); //上一行代码已经结束了程序，这行代码不会执行
 ​
     }
 }

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。