Java中的內(nèi)部類和常用類用法解讀

更新時(shí)間：2025年05月12日 11:47:52 作者：NaclarbCSDN

這篇文章主要介紹了Java中的內(nèi)部類和常用類用法,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教

內(nèi)部類和常用類

內(nèi)部類

概念：在一個(gè)類的內(nèi)部再定義一個(gè)完整的類

 package com.object.demo01;
 ?
 public class Body {
     private String name;
     class Header{
         //內(nèi)部類也會(huì)生成一個(gè)class文件 編譯之后可以生成獨(dú)立的字節(jié)碼文件
         //內(nèi)部類可為外部類提供必要的功能組件
         public void show() {    
             System.out.println(name);   //內(nèi)部類可以直接訪問(wèn)外部類的私有成員，而不破壞封裝
         }
     }
 }

成員內(nèi)部類

package com.object.demo02;
 ?
 //外部類
 public class Outer {
     //實(shí)例變量
     private String name = "張三";
     private int age = 18;
 ?
     //內(nèi)部類 與實(shí)例變量、實(shí)例方法同級(jí)別的類
     class Inner {
         private String address = "北京";
         private String phone = "110";
 ?
         private String name =  "李四"; 
         
         //private static int scores = 86; 內(nèi)部類不能定義靜態(tài)成員
         private static final int scores = 86; //但是可以定義靜態(tài)常量
         //方法
         public void show() {
             //打印外部類的屬性
             System.out.println(name);   //內(nèi)部類屬性和外部類屬性名字相同，優(yōu)先打印內(nèi)部類
             System.out.println(Outer.this.name);    
             System.out.println(age);    //可以在age前加上Outer.this這樣更清晰 可讀性
             //打印內(nèi)部類的屬性
             System.out.println(address);        //同理可以加上this.
             System.out.println(phone);          //同理加上this.
         }
     }
 }

 package com.object.demo02;
 ?
 public class TestOuter {
     public static void main(String[] args) {
         //內(nèi)部類的創(chuàng)建必須依賴外部類對(duì)象
 //        //1.先創(chuàng)建一個(gè)外部類對(duì)象
 //        Outer outer = new Outer();
 //        //2.創(chuàng)建一個(gè)內(nèi)部類對(duì)象
 //        Outer.Inner inner = outer.new Inner();
 ?
         //一步到位
         Outer.Inner inner = new Outer().new Inner();
 ?
         inner.show();
     }
 }

靜態(tài)內(nèi)部類

不依賴內(nèi)部類對(duì)象，可直接創(chuàng)建或通過(guò)類名訪問(wèn)，可聲明靜態(tài)成員

 package com.object.demo03;
 ?
 //外部類
 public class Outer {
     private String name = "xxx";
     private int age = 18;
 ?
     //靜態(tài)內(nèi)部類：和外部類相同
     static class Inner {    //只有內(nèi)部類才可以用static修飾，正常的類不能用static
         private String address = "上海";
         private String phone = "110";
 ?
         //靜態(tài)成員
         private static int count = 10000;
 ?
         public void show() {
             //如何調(diào)用外部類的屬性呢
             //System.out.println(name); 不對(duì)
             Outer outer = new Outer();
             System.out.println(outer.name);
             System.out.println(outer.age);
             //調(diào)用靜態(tài)內(nèi)部類的屬性和方法
             System.out.println(address);
             System.out.println(phone);
             //調(diào)用靜態(tài)內(nèi)部類的靜態(tài)屬性
             System.out.println(Inner.count);
 ?
         }
     }
 }

package com.object.demo03;
 ?
 public class Test {
     public static void main(String[] args) {
         //靜態(tài)內(nèi)部類相當(dāng)于一個(gè)外部類
         //直接創(chuàng)建靜態(tài)內(nèi)部類對(duì)象
         Outer.Inner inner  =new Outer.Inner();  //沒(méi)有new Outer();
         //調(diào)用方法
         inner.show();
     }
 }

局部?jī)?nèi)部類

定義在外部類方法中，作用范圍僅限于當(dāng)前方法

package com.object.demo04;
 ?
 public class Outer {
     private String name = "張三";
     private int age = 18;
 ?
     public void show() {
         //定義局部變量
         final String address = "深圳";    //局部?jī)?nèi)部類訪問(wèn)外部類當(dāng)前方法的局部變量時(shí)，因無(wú)法保障變量的聲明周期與自身相同，變量修飾必須為final
 ?
         //局部?jī)?nèi)部類：注意不能加任何訪問(wèn)修飾符
         class Inner {   //在堆里 不會(huì)消失
             private String phone = "110";
             private String email = "111@qq.com";
 ?
            // private static int count = 0; 局部?jī)?nèi)部類里不能有靜態(tài)屬性，同樣可以有靜態(tài)常量
             
             public void show2() {
                 //訪問(wèn)外部類的屬性 但是show被static修飾就不能訪問(wèn)
                 //因?yàn)閟tatic 和類一起加載 外部類屬性還沒(méi)加載出來(lái)
                 System.out.println(name);   //可以加上Outer.this. 可讀性強(qiáng)
                 System.out.println(age);
                 //訪問(wèn)內(nèi)部類屬性
                 System.out.println(phone);  //可以加上this.
                 System.out.println(email);  //同上
                 
                 //訪問(wèn)局部變量 jdk1.7要求是常量 jdk1.8自動(dòng)加上final
                 System.out.println(address);
             }
         }
         
         //創(chuàng)建內(nèi)部類對(duì)象
         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();
 ?
     }
 }

匿名內(nèi)部類

沒(méi)有類名的局部?jī)?nèi)部類
必須繼承一個(gè)父類或者實(shí)現(xiàn)一個(gè)接口
優(yōu)點(diǎn)：減少代碼量
缺點(diǎn)：可讀性較差

package com.object.demo05;
 ?
 //接口
 public interface USB {
     //定義一個(gè)服務(wù)方法
     void service();
 }

package com.object.demo05;

public class Mouse implements USB {
    @Override
    public void service() {
        System.out.println("連接成功，鼠標(biāo)開始工作");

    }
}

package com.object.demo05;

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


        //創(chuàng)建接口類型變量
        //USB usb = new Mouse();
        //usb.service();

        //局部?jī)?nèi)部類
    class Fan implements USB {


        @Override
        public void service() {
            System.out.println("連接成功，風(fēng)扇開始工作");
        }
    }
        USB usb = new Fan();
        usb.service();

    }
}

這是使用局部?jī)?nèi)部類。局部?jī)?nèi)部類只使用一次，可以用匿名內(nèi)部類進(jìn)行優(yōu)化->

 package com.object.demo05;
 ?
 public class Test {
     public static void main(String[] args) {
 ?
         //使用匿名內(nèi)部類創(chuàng)建對(duì)象(相當(dāng)于創(chuàng)建了一個(gè)局部?jī)?nèi)部類)
         // USB usb = new USB();  報(bào)錯(cuò)-接口不能實(shí)例化
         USB usb = new USB() {
             @Override
             public void service() {
                 System.out.println("連接成功，風(fēng)扇開始工作");
             }
         };
         usb.service();
 ?
         //使用匿名內(nèi)部類優(yōu)化
 ?
     }
 }

常用類

Object類

在java.lang包下

超類，所有對(duì)象都繼承這個(gè)類的方法

getClass()方法

返回class類型

應(yīng)用：判斷兩個(gè)引用中實(shí)際存儲(chǔ)對(duì)象類型是否一致

 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是不是同一個(gè)類型
        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類型

哈希值根據(jù)對(duì)象的地址或字符串或數(shù)字使用hash算法計(jì)算出來(lái)的int類型的數(shù)值

一般情況下相同對(duì)象返回相同哈希碼

以上節(jié)課的代碼為例

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

可以根據(jù)程序需求重寫該方法

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進(jìn)制哈希值

想要看到具體的屬性就要對(duì)toString進(jìn)行重寫

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方法：判斷兩個(gè)對(duì)象是否相等
        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));  //雖然兩者的屬性相同，但是分別開辟了一個(gè)內(nèi)存空間 false

    }
}

要讓屬性相同返回true就要對(duì)equals進(jìn)行重寫

 @Override
     public boolean equals(Object obj) {
         //1.判斷兩個(gè)對(duì)象是否是同一個(gè)引用
         if (this == obj) {
             return true;
         }
         //2.判斷obj是否為null
         if (obj == null) {
             return false;
         }
         //3.判斷是否為同一個(gè)類型
 //        if(this.getClass() == obj.getClass()) {
 //            return true;
 //        }
         if (obj instanceof Student) {    //instanceof判斷對(duì)象是否是某種類型
             //4.強(qiáng)制類型轉(zhuǎn)換
             Student s = (Student) obj;
             //5.比較屬性
             if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                 return true;
             }
         }
         return false;
     }

finalize()方法

該方法一般情況下，程序員不會(huì)調(diào)用

當(dāng)對(duì)象被判定為垃圾對(duì)象時(shí)，由JVM自動(dòng)調(diào)用此方法，用以標(biāo)記垃圾對(duì)象，進(jìn)入回收隊(duì)列
垃圾對(duì)象：沒(méi)有有效引用指向此對(duì)象時(shí)，為垃圾對(duì)象
垃圾回收：由GC銷毀垃圾對(duì)象，釋放數(shù)據(jù)存儲(chǔ)空間
自動(dòng)回收機(jī)制：JVM的內(nèi)存耗盡，釋放數(shù)據(jù)存儲(chǔ)空間
手動(dòng)回收機(jī)制：使用System.gc()，通知JVM執(zhí)行垃圾回收

@Override
     protected void finalize() throws Throwable {
         System.out.println(this.name +"對(duì)象被回收了");
     } //對(duì)finalize方法進(jìn)行重寫

 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被回收
     }
 }

包裝類

基本數(shù)據(jù)所對(duì)應(yīng)的引用數(shù)據(jù)類型

基本數(shù)據(jù)類型	包裝類
boolean	Boolean
byte	Byte
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double

類型轉(zhuǎn)換與裝箱拆箱

棧里面的對(duì)象拿到堆里面：裝箱
堆里面的對(duì)象拿到棧里面：拆箱

package com.object.demo07;

public class Test {
    public static void main(String[] args) {
        //類型轉(zhuǎn)換：裝箱：基本類型轉(zhuǎn)成引用類型的過(guò)程
        int num1 = 18;  //基本類型 棧
        //使用Integer類創(chuàng)建對(duì)象 下面兩種方式都行
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("裝箱");
        System.out.println(integer1);
        System.out.println(integer2);


        //類型轉(zhuǎn)換：拆箱：引用類型轉(zhuǎn)成基本類型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //JDK1.5以后，提供自動(dòng)裝箱和拆箱
        int age = 18;
        //自動(dòng)裝箱
        Integer integer4 =age;
        System.out.println("自動(dòng)裝箱");
        System.out.println(integer4);
        //自動(dòng)拆箱
        int age2 =  integer4;
        System.out.println("自動(dòng)拆箱");
        System.out.println(age2);


    }
}

基本類型轉(zhuǎn)換

package com.object.demo07;

public class Test {
    public static void main(String[] args) {
        
        //基本類型轉(zhuǎn)成字符串
        int n1 = 15;
        //1.使用+號(hào)
        String s1 = n1 + "";
        //2.使用Integer中的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1,16);    //toString重載方法，將它轉(zhuǎn)成指定進(jìn)制
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        //字符串轉(zhuǎn)成基本類型
        String str = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);

        //boolean字符串形式轉(zhuǎn)成基本類型，"true"-->true,只要這個(gè)字符串不是true就是false
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

    }
}

整數(shù)緩沖區(qū)

Java預(yù)先創(chuàng)建了256個(gè)常用的整數(shù)包裝類型對(duì)象Integer

我們接下來(lái)從一個(gè)程序來(lái)加深這句話的理解

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);   //引用類型在堆內(nèi)存開辟了兩個(gè)不同空間 false

        Integer integer3 = 100; //自動(dòng)裝箱  即Integer integer3 = Integer.valueOf(100) 后續(xù)同理
        Integer integer4 = Integer.valueOf(100); //自動(dòng)裝箱
        System.out.println(integer3 == integer4);
        //integer3,integer4都是引用類型，答案也是false嗎？ 結(jié)果是true

        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5 == integer6);
        //這三行和上面三行幾乎沒(méi)差別 結(jié)果卻相反 是false
    }
}

自動(dòng)裝箱是使用Integer.valueOf()

問(wèn)題就出在這個(gè)方法，ctrl+鼠標(biāo)看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[] 數(shù)組

數(shù)組在緩沖區(qū)中有256個(gè)位置，將100這個(gè)值取地址給integer3和integer4,兩者地址相同，所以返回true

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

200不在-128~127 return new Integer(i); 和Integer1,2一樣，在堆內(nèi)存開辟新空間

String類

String概述

字符串是常量，創(chuàng)建之后不消失
字符串字面量存儲(chǔ)在字符串池中，可以共享

package com.object.demo07;

public class Test3 {
    public static void main(String[] args) {
        String name = "hello";  //"hello" 存儲(chǔ)在常量池中
        System.out.println(name.hashCode());    //假如hashcode是x
        name = "zhangsan";    //"zhangsan"賦值給name 給字符串賦值時(shí)，并沒(méi)有在原字符串上修改數(shù)據(jù)，而是重新開辟一塊空間
        String name2 = "zhangsan";

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

String常用方法

public int length(): 返回字符串長(zhǎng)度
public char charAt(int index): 根據(jù)下標(biāo)獲取字符
public boolean contains(String str):判斷當(dāng)前字符串中是否包含str

package com.object.demo07;

public class Test3 {
    public static void main(String[] args) {
        //字符串方法的使用
        //length();返回字符串的長(zhǎng)度
        //charAt(int index);返回某個(gè)位置的字符
        //contains(String str);判斷是否是某個(gè)子字符串

        String content = "java是世界上最好的編程語(yǔ)言";
        System.out.println(content.length());   //15
        System.out.println(content.charAt(0));  //第一個(gè)字符
        System.out.println(content.charAt(content.length()-1)); //最后一個(gè)字符
        System.out.println(content.contains("java"));
        System.out.println(content.contains("php"));


    }
}

public char[] toCharArray():將字符串轉(zhuǎn)換成數(shù)組
public int indexOf(String str):查找str首次出現(xiàn)的下標(biāo)，存在，返回該下標(biāo)，不存在，返回-1
public int lastIndexOf(String str):查找字符串在當(dāng)前字符串中最后一次出現(xiàn)的下標(biāo)

package com.object.demo07;

import java.util.Arrays;

public class Test3 {
    public static void main(String[] args) {
        
        //字符串方法的使用
        //toCharArray();返回字符串對(duì)應(yīng)的數(shù)組
        //indexOf();返回子字符串出現(xiàn)的位置
        //lastIndexOf();返回字符串最后一次出現(xiàn)的位置
		String content = "java是世界上最好的java編程語(yǔ)言,java真香";

        System.out.println(content.toCharArray());
        System.out.println(Arrays.toString(content.toCharArray())); //把這個(gè)數(shù)組當(dāng)字符串輸出出來(lái)
        System.out.println(content.indexOf("java"));    //0
        System.out.println(content.indexOf("java", 4)); //找第二個(gè)java,從角標(biāo)為4開始找，但是最終結(jié)果還是以第一個(gè)字符為0
        System.out.println(content.lastIndexOf("java"));    //找最后一個(gè)java


    }
}

public String trim():去掉字符串前后的空格
public String toUpperCase():將小寫轉(zhuǎn)成大寫
public String toLowerCase():將大寫轉(zhuǎn)成小寫
public boolean endsWith(String str):判斷字符串是否以str結(jié)尾
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(); 把小寫轉(zhuǎn)成大寫
        //toLowerCase(); 把大寫轉(zhuǎn)成小寫
        //endsWith(str); 判斷是否以str結(jié)尾，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):根據(jù)str做拆分

package com.object.demo07;

import java.util.Arrays;

public class Test3 {
    public static void main(String[] args) {
        
        //字符串方法的使用
        //replace(char old, char new);用新的字符串替換舊的字符串
        //split();對(duì)字符串進(jìn)行拆分
        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個(gè)字符串
        for (String s : arr) {
            System.out.println(s);
        }
        String say1 = "java is the best programming language,java xiang";
       //想要把字符串空格和逗號(hào)去掉來(lái)分割
        String[] arr1 = say1.split("[ ,]");
        for (String s : arr1) {
            System.out.println(s);
        }
        String say2 = "java is the best      programming language,java xiang";
        //想要多個(gè)空格也能去除
        String[] arr2 = say2.split("[ ,]+");
        for (String s : arr2) {
            System.out.println(s);
        }
        System.out.println("--------------------------");
        //補(bǔ)充兩個(gè)方法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));   //兩個(gè)字符串首個(gè)字符的ASCII碼值相減 -23,首個(gè)相同就減下一個(gè)以此類推

        String s5 = "abc";
        String s6 = "abcxyz";
        System.out.println(s5.compareTo(s6));   //s5剛好在s6里面的前面，則比較長(zhǎng)度 -3
    }
}

案例分析

package com.object.demo07;

//案例演示
//已知String str =  "this is a text";
/*
* 將str中的單詞單獨(dú)獲取出來(lái)
* 將str中的text替換為practice
* 在text前面插入一個(gè)easy
* 將每個(gè)單詞的首字母改為大寫

* */
public class Test4 {
    public static void main(String[] args) {
        String str = "this is a text";
        //將str中的單詞單獨(dú)獲取出來(lái)
        String[] arr = str.split(" ");
        for(String str1 : arr) {
            System.out.println(str1);
        }

        //將str中的text替換為practice
       String s1 = str.replace("text", "practice");

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

        //將每個(gè)單詞的首字母改為大寫
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:可變長(zhǎng)字符串，運(yùn)行效率慢，線程安全多線程用
StringBuilder:可變長(zhǎng)字符串，運(yùn)行效率快，線程不安全單線程用

效率比String高，比String更節(jié)省內(nèi)存

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(); 翻轉(zhuǎn)
        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) {
        //驗(yàn)證效率StringBuilder高于String
        long startTime = System.currentTimeMillis();    //開始時(shí)間
        String string = "";
        for (int i = 0; i < 999; i++) {
            string += i;    //字符串的拼接
        }
       
        System.out.println(string.toString());
        long endTime = System.currentTimeMillis();
        System.out.println("用時(shí)"+ (endTime - startTime));

    }
}

package com.object.demo08;

public class Demo02 {
    public static void main(String[] args) {
        //驗(yàn)證效率StringBuilder高于String
        long startTime = System.currentTimeMillis();    //開始時(shí)間
        
        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("用時(shí)"+ (endTime - startTime));
    }
}

BigDecimal

位置：java.math包中
作用：精確計(jì)算浮點(diǎn)數(shù)
創(chuàng)建方法：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);
        //輸出結(jié)果0.0999999999...
        //很多實(shí)際應(yīng)用中需要精確計(jì)算，而double是近似值存儲(chǔ)，需要借助BigDecimal
        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);


        //BigDecimal,大的浮點(diǎn)數(shù)精確計(jì)算
        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"));    //出現(xiàn)異常
        BigDecimal r = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);   //保留兩位小數(shù)，四舍五入
        System.out.println(r);


    }

}

Date類

Date表示特定的瞬間，精確到毫秒。Date中大部分方法已經(jīng)被Calendar類中方法取代

package com.object.demo08;

import java.util.Date;

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

        //1.創(chuàng)建Date對(duì)象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());   //打印當(dāng)前時(shí)間 用空格連接
        System.out.println(date1.toLocaleString()); //打印當(dāng)前時(shí)間 用-連接，已過(guò)時(shí)

        //昨天
        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); //比較兩者的毫秒值 毫秒值相減 正數(shù)返回1，負(fù)數(shù)返回-1
        System.out.println(d);

        //比較數(shù)相等 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) {
        //創(chuàng)建Calendar對(duì)象
        Calendar calendar = Calendar.getInstance(); //Calendar是protected不能直接new
        System.out.println(calendar.toString());    //打印的東西特別多，不是我們想要看到的形式
        System.out.println(calendar.getTime().toString());  //把calendar轉(zhuǎn)成date類
        System.out.println(calendar.getTimeInMillis());
        //獲取時(shí)間信息
        //獲取年
        int year = calendar.get(Calendar.YEAR); //也可以把Calendar.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);
        //獲取小時(shí)
        int hour = calendar.get(Calendar.HOUR_OF_DAY);  //24小時(shí)制
        int hour2 = calendar.get(Calendar.HOUR);    //12小時(shí)制
        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);

        //修改時(shí)間
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 5);    //修改日
        System.out.println(calendar2.getTime().toLocaleString());

        //add修改時(shí)間
        calendar2.add(Calendar.HOUR, 1);
        System.out.println(calendar2.getTime().toLocaleString());
        calendar2.add(Calendar.HOUR, -1);   //減少時(shí)間
        System.out.println(calendar2.getTime().toLocaleString());

        //補(bǔ)充
        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類

將日期轉(zhuǎn)成特定格式

 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 {
         //創(chuàng)建SimpleDateFormat對(duì)象 y年 M月 d日 H時(shí) m分 s秒
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 ?
         //創(chuàng)建一個(gè)Date
         Date date = new Date();
 ?
         //格式化Date 把日期轉(zhuǎn)化成字符串
         System.out.println(sdf.format(date));
 ?
         //解析 把字符串轉(zhuǎn)成日期
         Date date2 = sdf.parse("2025-5-11 12:00:00");   //格式和上面的pattern一樣
         System.out.println(date2);
 ?
     }
 }

System類

主要用于互毆去系統(tǒng)的屬性數(shù)據(jù)和其他操作，構(gòu)造方法私有

 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) {
         //不用創(chuàng)建System對(duì)象
         //arraycopy(); 參數(shù)：src,srcPos(指的是src的下標(biāo)),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(),獲取當(dāng)前系統(tǒng)時(shí)間，返回毫秒值 可以用來(lái)計(jì)算代碼的執(zhí)行時(shí)間
         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("用時(shí)"+(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("程序結(jié)束"); //上一行代碼已經(jīng)結(jié)束了程序，這行代碼不會(huì)執(zhí)行
 ?
     }
 }