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

本文主要是介绍Java中的内部类和常用类用法解读，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Java中的内部类和常用类用法解读》：本文主要介绍Java中的内部类和常用类用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教...

内部类和常用类

内部类

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

 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[] China编程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("程序结束"); //上一行代码已经结束了程序，这行代码不会执行
 
     }
 }

总结

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

这篇关于Java中的内部类和常用类用法解读的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

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

目录

内部类和常用类

内部类

成员内部类

静态内部类

局部内部类

匿名内部类

常用类

Object类

getClass()方法

hashCode()方法

toString()方法

equals()方法

finalize()方法

包装类

类型转换与装箱拆箱

整数缓冲区

String类

String概述

String常用方法

案例分析

StringBuffer和StringBuilder

BigDecimal

Date类

Calendar类

SimpleDateFormat类

System类

总结

相关文章

SpringBoot快速搭建TCP服务端和客户端全过程

Java如何根据文件名前缀自动分组图片文件

Java中 instanceof 的用法详细介绍

Java实现MinIO文件上传的加解密操作

Java使用WebView实现桌面程序的技术指南

防止SpringBoot程序崩溃的几种方式汇总

Java Jackson核心注解使用详解

Spring Validation中9个数据校验工具使用指南

MySQL连接池(Pool)常用方法详解

Java对接Dify API接口的完整流程