­

Java常用類

Object類

超類、基類，所有類的直接或間接父類，位於繼承樹的最頂層

任何類，如沒有書寫extends顯示繼承某個類，都默認直接繼承Object類，否則為間接繼承

  • Object類中所定義的方法，是所有對象都具備的方法
  • Object類型可以存儲任何對象
    • 作為參數，可接受任何對象
    • 作為返回值，可返回任何對象

getClass() 方法

  • public final Class<?> getClass(){}

  • 返回引用中存儲的實際對象類型

  • 應用：通常用於判斷兩個引用中實際存儲對象類型是否一致

【演示】

package com.commonclass.object.demo01;

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
package com.commonclass.object.demo01;

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

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("張三", 18);
        Student s2 = new Student("李四", 20);
        Teacher t1 = new Teacher("王五", 28);
        Class c1 = s1.getClass();// getClass()返回Class類型
        Class c2 = s2.getClass();
        Class c3 = t1.getClass();
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        // 判斷s1和s2是不是同類型
        if (c1 == c2){
            System.out.println("s1和s2是同類型");
        } else{
            System.out.println("s1和s2不是同類型");
        }
        // 判斷s1和t1是不是同類型
        if (c1 == c3){
            System.out.println("s1和t1是同類型");
        } else{
            System.out.println("s1和t1不是同類型");
        }
    }
}
執行結果：
class com.commonclass.object.demo01.Student
class com.commonclass.object.demo01.Student
class com.commonclass.object.demo01.Teacher
s1和s2是同類型
s1和t1不是同類型

hashCode()方法

  • public int hashCode(){}
  • 返回該對象的哈希碼值
  • 哈希值根據對象的地址或字元串或數字使用hash演算法計算出來的int類型的值
  • 一般情況下相同對象返回相同哈希碼

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("張三", 18);
        Student s2 = new Student("李四", 20);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s2;// 相同對象返回相同哈希碼
        System.out.println(s3.hashCode());
    }
}
輸出結果：
1163157884
1956725890
1956725890

toString()方法

  • public String toSring(){}

  • 返回該對象的字元串表示（表現形式）

  • 可以根據程式需求重寫該方法，如：展示對象各個屬性值

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("張三", 18);
        System.out.println(s1.toString());
    }
}
執行結果：
Student{name='張三', age=18} 

若Student類中未重寫toString方法，則輸出com.commonclass.object.demo02.Student@4554617c// @4554617c為哈希值

equals()方法

  • public boolean equals(Object obj){}

  • 默認實現為(this == obj), 比較兩個對象地址是否相同

  • 可進行覆蓋，比較兩個對象的內容是否相同

請注意，無論何時覆蓋該方法，通常需要覆蓋hashCode方法，以便維護hashCode方法的通用合約，該方法規定相等的對象必須具有相等的哈希碼。

重寫equals方法步驟

  1. 比較兩個引用是否指向同一個對象
  2. 判斷obj是否為null
  3. 判斷兩個引用指向的實際對象類型是否一致
  4. 強制類型轉換
  5. 依次比較各個屬性值是否相同

【演示】

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 int getAge() {
        return age;
    }

    @Override// 重寫equals方法
    public boolean equals(Object o) {
        if (this == o) {// 1.比較兩個引用是否執行同一個對象
            return true;
        }
        if (o != null) {// 2.判斷obj是否為null
            return true;
        }
        if (getClass() == o.getClass()){// 3.判斷兩個引用指向的實際對象類型是否一致
            return true;
        }
        if (o instanceof Student){
            Student student = (Student) o;// 4.強制類型轉換
            if (this.age == student.getAge() && this.name.equals(student.getName())){// 5.依次比較各個屬性值是否相同
                return true;
            }
        }

        return false;
    }

    @Override// 重寫hashCode方法
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("張三", 18);
        Student s2 = new Student("張三", 18);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s1.equals(s2));
    }
}
執行結果：
24022538
24022538
true

【注意】若Student類中未重寫equals方法和hashCode方法，則輸出1163157884 1956725890
false，s1和s2的哈希碼不同，儘管s1和s2傳遞的參數相同，但是其地址不同，所以要讓它們的equals方法返回為true（引用的是相同的對象），則必須重寫其equals方法及hashCode方法。

finalize() 方法

  • 當對象被判定為垃圾對象時，由JVM自動調用此方法，用以標記垃圾對象，進入回收隊列
  • 垃圾對象：沒有有效引用指向此對象時，為垃圾對象
  • 垃圾回收：由gc銷毀垃圾對象，釋放數據存儲空間
  • 自動回收機制：JVM的記憶體耗盡，一次性回收所有垃圾對象
  • 手動回收機制：使用System.gc();通知JVM執行垃圾回收

【演示】

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"對象被回收了");
    }
}
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("張三", 20);
        new Student("李四", 18);// 垃圾對象：沒有有效引用指向此對象
        System.gc();
        System.out.println("回收垃圾");
    }
}
執行結果：
李四對象被回收了
回收垃圾

包裝類

  • 基本數據類型所對應的引用數據類型
  • Object 可統一所有數據，包裝類的默認值是null
基本數據類型 包裝類型
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

裝箱(基本數據類型–>引用類型)

Method and Description
Byte(byte value) 構造一個新分配的 Byte對象，該對象表示指定的 byte值。
Short(short value) 構造一個新分配的 Short對象，表示指定的 short值。
Integer(int value) 構造一個新分配的 Integer對象，該對象表示指定的 int值。
Long(long value) 構造一個新分配的 Long對象，代表指定的 long參數。
Float(float value) 構造一個新分配的 Float對象，該對象表示基元 float參數。
Double(double value) 構造一個新分配的 Double對象，表示原始 double參數。
Boolean(boolean value) 分配一個 Boolean對象，代表 value參數。
Character(char value) 構造一個新分配的 Character對象，代表指定的 char值。

除以上方法還有各包裝類的valueOf( )方法。例如Integer integer = Integer.valueOf(1)；

拆箱(引用類型–>基本數據類型)

Number父類中提供的6個共性方法

包裝類Byte,Double,Flaot,Integer,Long,Short均是Number的子類

Modifier and Type Method and Description
byte byteValue() 返回指定號碼作為值 byte ，這可能涉及舍入或截斷。
abstract double doubleValue() 返回指定數字的值為 double ，可能涉及四捨五入。
abstract float floatValue() 返回指定數字的值為 float ，可能涉及四捨五入。
abstract int intValue() 返回指定號碼作為值 int ，這可能涉及舍入或截斷。
abstract long longValue() 返回指定數字的值為 long ，可能涉及四捨五入或截斷。
short shortValue() 返回指定號碼作為值 short ，這可能涉及舍入或截斷。
Modifier and Type Method and Description
boolean booleanValue() 將此 Boolean對象的值作為布爾基元返回。
char charValue() 返回此 Character對象的值。

【演示】

public class Test {
    public static void main(String[] args) {
        /* 裝箱 基本數據類型-->引用類型 */
        int num1 = 10;// 基本數據類型
        Integer integer1 = new Integer(num1);// 使用Integer類創建對象
        Integer integer2 = Integer.valueOf(num1);
        /* 拆箱 引用類型-->基本數據類型)*/
        int num2 = integer1.intValue();

        /*
        jdk1.5之後提供自動裝箱和拆箱
        但是其原理仍是上述的方法
         */
        // 自動裝箱
        Integer integer3 = 8;// Integer integer3 = = Integer.valueOf(8);
        // 自動拆箱
        int num3 = integer3;
    }
}

字元串與基本類型之間的轉換

基本數據類型轉換為字元串類型
1.使用”+”
2.使用各包裝類中的toString()方法

字元串類型轉化為基本數據類型
1.使用×××.parse×××()方法

boolean字元串轉換為基本數據類型：”true”—->true,非”true”—->false

【演示】

public class Test02 {
    public static void main(String[] args) {
        /* 基本數據類型轉換為字元串類型 */
        int a = 255;
        String str1 = a + "";// 使用"+"
        String str2 = Integer.toString(a);// 使用Integer中的toString方法
        // 注:Integer.toString方法的重載可以將int型數據轉化為所設置的進位數據的字元串形式
        String str3 = Integer.toString(a, 16);// 100的16進位字元串形式
        
        /* 字元串類型轉化為基本數據類型 */
        String str4 = "888";
        int b = Integer.parseInt(str4);// 使用Integer中的parseInt方法
        String str5 = "fe";
        int c = Integer.parseInt(str5, 16);// 使用Integer中的重載parseInt方法（fe為16進位的數據，轉換為int型數據為255）
        String str6 = "true";
        String str7 = "te";
        boolean flag1 = Boolean.parseBoolean(str6);
        boolean flag2 = Boolean.parseBoolean(str7);// "te"不是"true",即為false
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(b);
        System.out.println(c);
        System.out.println(flag1);
        System.out.println(flag2);
    }
}
輸出結果：
255
255
ff
888
254
true
false

注意：需保證類型兼容，否則拋出NumberFormatException異常

整數緩衝區

  • Java預先創建了256個常用的整數包裝類型對象
  • 在實際應用當中，對已創建的對象進行復用

【Integer中valueOf方法源碼】

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
// 只要i在[-128,127]這個範圍內，就直接對已創建的對象進行復用
// 只要i在[-128,127]這個範圍外，才new Integer(i)

【演示】

public class Test03 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);// flase 因為是用的new的對象
        Integer integer3 = 100;// 自動裝箱:Integer integer3 = Integer.valueOf(100);
        Integer integer4 = 100;// 100∈[-128,127],該包裝類型對象已預先創建
        System.out.println(integer3 == integer4);// true 因為Java預先創建了256個常用的整數包裝類型對象，直接調用
        Integer integer5 = Integer.valueOf(200);
        Integer integer6 = Integer.valueOf(200);// 200∉[-128,127],該包裝類型對象需重新創建，即new
        System.out.println(integer5 == integer6);// flase 因為是用的new的對象
    }
}

String 類

  • 字元串是常量，創建之後不可改變
  • 字元串字面值存儲在字元串池中，可以共享
  • String s = "Hello";產生一個對象，字元串池中存儲
  • String s = new String("Hello"); 產生兩個對象，堆、池各一個

【演示】

public class Test01 {
    public static void main(String[] args) {
        String name1 = "hello";
        name1 = "張三";
        String name2 = "張三";
        String str1 = new String("Java");
        String str2 = new String("Java");
        System.out.println(str1 == str2);// false 因為其引用的對象不同
        System.out.println(str1.equals(str2));// true
    }
}

【記憶體分析】

常用方法

方法 描述
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 int lastIndexOf(String str) 查找字元串在當前字元串中最後一次出現的下標索引
public String trim() 去掉字元串前後的空格
public String toUpperCase() 將小寫轉成大寫
public boolean endWith(String str) 判斷字元串是否以str結尾
public String replace(char oldChar, char newChar) 將舊字元串替換成新字元串
public StringE] split(String str) 根據str做拆分
public int equals(Object anObject) 將此字元串與指定對象進行比較
public boolean compareTo(String anotherString) 按字典順序比較兩個字元串

【演示】

public class Test02 {
    public static void main(String[] args) {
        /*
        1. length(); 返回字元串長度
        2. charAt(int index); 返回某個位置的字元
        3. contains(String str); 判斷是否包含某個字元串
         */
        String str1 = "java是最好的語言";
        System.out.println(str1.length());// 返回該字元串的長度
        System.out.println(str1.charAt(0));// 返回該字元串第一位的字元
        System.out.println(str1.charAt(str1.length() - 1));// 返回該字元串最後一位的字元
        System.out.println(str1.contains("java"));// 判斷該字元串中是否包含"java"
    }
}
執行結果：
10
j
言
true

import java.util.Arrays;

public class Test03 {
    public static void main(String[] args) {
        /*
        4. toCharArray(); 返回字元串對應數組
        5. indexOf(); 返回字元串首次出現的位置
        6. lastIndexOf(); 返回字元串最後一次出現的位置
         */
        String str = "java是最好的語言java也是最簡單的語言java";
        System.out.println(str.toCharArray());// 返回該字元串的對應數組
        System.out.println(Arrays.toString(str.toCharArray()));// 返回該字元串的對應數組內容的字元串表示形式
        System.out.println(str.indexOf("java"));// 返回"java"在該字元串首次出現的位置
        System.out.println(str.indexOf("java", 4));// 返回"java"在該字元串從索引4開始首次出現的位置
        System.out.println(str.lastIndexOf("java"));// 返回"java"在該字元串最後出現的位置
    }
}
執行結果：
java是最好的語言java也是最簡單的語言java
[j, a, v, a, 是, 最, 好, 的, 語, 言, j, a, v, a, 也, 是, 最, 簡, 單, 的, 語, 言, j, a, v, a]
0
10
22

public class Test04 {
    public static void main(String[] args) {
        /*
        7. trim(); //去掉字元串前後空格
        8. toUpperCase();將字元串中的字母小寫轉換為大寫 toLowerCase(); 將字元串中的字母大寫轉換為小寫
        9. endWith(str); 判斷是否以str結尾 startWith(str);  判斷是否以str開頭
         */
        String str = " My name is ZhangSan ";
        System.out.println(str.trim());// 去掉該字元串前後空格
        System.out.println(str.toUpperCase());// 將該字元串中的字母小寫轉換為大寫
        System.out.println(str.toLowerCase());// 將該字元串中的字母大寫轉換為小寫
        System.out.println(str.endsWith(" "));// 判斷該字元串是否以" "結尾
        System.out.println(str.startsWith(" "));// 判斷該字元串是否以" "開頭
    }
}
執行結果：
My name is ZhangSan
 MY NAME IS ZHANGSAN 
 my name is zhangsan 
true
true

public class Test05 {
    public static void main(String[] args) {
        /*
        10. replace(char old, char new); 用新的字元或字元串替換舊的字元或字元串
        11. split(); 對字元串拆分
         */
        String str1 = "java是最好的語言java也是最簡單的語言";
        System.out.println(str1.replace("java", "php"));// 用"php"替換該字元串中的"java"
        String str2 = "java is the best language";
        String[] array1 = str2.split(" ");// 以" "對該字元串拆分
        for (String i : array1){
            System.out.println(i);
        }
        String str3 = "java,is the,best language";
        String[] array2 = str2.split("[ ,]");// 以" "或者","對該字元串拆分
        for (String j : array2){
            System.out.println(j);
        }
        String str4 = "java,,,is   the,,best language";
        String[] array3 = str3.split("[ ,]+");// 以多個" "或者多個","對該字元串拆分 
        for (String k : array3){
            System.out.println(k);
        }
    }
}
執行結果：
php是最好的語言php也是最簡單的語言
java
is
the
best
language
java
is
the
best
language
java
is
the
best
language

public class Test06 {
    public static void main(String[] args) {
        /*
        12. equals();比較兩個字元串的內容是否相等
            equalsIgnoreCase();忽略字母大小寫比較兩個字元串內容
        13. compareTo();按字典順序比較兩個字元串
            compareToIgnoreCase();忽略字母大小寫按字典順序比較兩個字元串
            兩字元串不同時比較字元字典序的ascii碼,兩字元串相同時比較長度 返回差值
         */
        String str1 = "hello";
        String str2 = "HELLO";
        String str3 = "hello world";
        System.out.println(str1.equals(str2));// 比較str1和str2字元串內容是否相同
        System.out.println(str1.equalsIgnoreCase(str2));// 忽略字母大小寫比較str1和str2字元串內容是否相同
        System.out.println(str1.compareTo(str2));// h的ASCII碼值為104，H的ASCII碼值為72,返回差值104-72= 32
        System.out.println(str1.compareTo(str3));// str1與str3的前半部分相同，則比較兩字元串的長度，返回差值5-11=-6
        System.out.println(str1.compareToIgnoreCase(str2));// 忽略字母大小寫，str1與str2字元串內容相同，則比較兩字元串長度，返回差值5-5=0
    }
}
執行結果：
false
true
32
-6
0

string類方法練習

需求：

  1. 已知String str = “this is a text”;
  2. 將str中的單詞單獨獲取
  3. 將str中的text替換成practice
  4. 在text前面插入一個easy
  5. 將每個單詞的首字母改為大寫

補充方法：public String substring(int beginIndex)

返回一個字元串，該字元串是此字元串的子字元串。 子字元串以指定索引處的字元開頭，並擴展到該字元串的末尾。beginIndex – 開始索引（含）

例子：”unhappy”.substring(2) returns “happy”
“Harbison”.substring(3) returns “bison”
“emptiness”.substring(9) returns “” (an empty string)

public class Practice {
    public static void main(String[] args) {
        String str = "this is a text";
        /* 將str中的單詞單獨獲取 */
        String[] array = str.split(" ");
        for (String s : array) {
            System.out.println(s);
        }
        /* 將str中的text替換成practice */
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
        /* 在text前面插入一個easy */
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);
        /* 將每個單詞的首字母改為大寫 */
        String str4 = "";
        for (int i = 0; i < array.length; i++) {
            char s = array[i].charAt(0);// 返回array[i]的首字母
            char sUpper = Character.toUpperCase(s);// 將array[i]的首字母轉換為大寫
            String strFirstUpper = sUpper + array[i].substring(1);// 將大寫的首字母與餘下字母串拼接起來
            //System.out.println(strFirstUpper);
            str4 += strFirstUpper + " ";
        }
        System.out.println(str4);
    }
}
執行結果：
this
is
a
text
this is a practice
this is a easy text
This Is A Text

可變字元串

  • StringBuffer : 可變長字元串，JDK1.0提供，運行效率慢、執行緒安全
  • StringBuilder : 可變長字元串、JDK5.0提供，運行效率快、執行緒不安全

效率都比String高且節省記憶體

StringBuffer&StringBuilder常用方法

以下方法StringBuffer 和 StringBuilder 用法一致

方法 描述
append() 追加
insert() 添加，插入
replace() 替換
delete() 刪除
reverse() 反轉

【演示】

public class Demo01 {
    public static void main(String[] args) {
        /*
        StringBuffer 和 StringBuilder 用法一致
         */
        StringBuffer str1 = new StringBuffer();
        // StringBuilder str1 = new StringBuilder();
        str1.append("Java");
        System.out.println(str1);// Java
        str1.append("是最好的語言");// 在"Java"後追加"是最好的語言"
        System.out.println(str1);// Java是最好的語言
        str1.insert(0, "我覺得");// 在第一個位置插入"我覺得"
        System.out.println(str1);// 我覺得Java是最好的語言
        str1.replace(0, 3, "他認為");// 用"他認為"替換[0, 3)的內容
        System.out.println(str1);// 他認為ava是最好的語言
        str1.delete(0, 3);// 刪除[0, 3)的內容
        System.out.println(str1);// Java是最好的語言
        // str1.delete(0, str1.length());刪除str1中所有的內容
        str1.reverse();// 反轉str1中的內容
        System.out.println(str1);// 言語的好最是avaJ
    }
}

【StringBuffer、StringBuilder效率都比String高】

public class Demo02 {
    public static void main(String[] args) {
        long start1 = System.currentTimeMillis();// String開始時間
        String str1 = "";
        for (int i = 0; i < 99999; i++) {
            str1 += i;
        }
        long end1 = System.currentTimeMillis();// String結束時間
        System.out.println("String用時"+(end1 - start1));
        long start2 = System.currentTimeMillis();// StringBuffer()開始時間
        StringBuffer str2 = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            str2.append(i);
        }
        long end2 = System.currentTimeMillis();// StringBuffer()結束時間
        System.out.println("StringBuffer用時"+(end2 - start2)); 
    }
}
執行結果：
String用時20291
StringBuffer用時3

public class Demo03 {
    public static void main(String[] args) {
        long start2 = System.currentTimeMillis();// StringBuffer()開始時間
        StringBuffer str2 = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            str2.append(i);
        }
        long end2 = System.currentTimeMillis();// StringBuffer()結束時間
        System.out.println("StringBuffer用時"+(end2 - start2));
        long start3 = System.currentTimeMillis();// StringBuilder開始時間
        StringBuilder str3 = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            str3.append(i);
        }
        long end3 = System.currentTimeMillis();// StringBuilder結束時間
        System.out.println("StringBuilder用時"+(end3 - start3));
    }
}
執行結果：
StringBuffer用時13
StringBuilder用時5

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 scal, RoundingMode mode)
參數scal :指定精確到小數點後幾位。
參數mode :指定小數部分的取捨模式，通常採用四捨五入的模式，取值為BigDecimal.ROUND_HALF_UP。

import java.math.BigDecimal;

public class Demo01 {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");// 需用字元串
        BigDecimal bd2 = new BigDecimal("0.9");
        BigDecimal result1 = bd1.add(bd2);// 加法
        System.out.println("1.0+0.9="+result1);
        BigDecimal result2 = bd1.subtract(bd2);// 減法
        System.out.println("1.0-0.9="+result2);
        BigDecimal result3 = bd1.multiply(bd2);// 乘法
        System.out.println("1.0*0.9="+result3);
        BigDecimal result4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println("(1.4-0.5)/0.9="+result4);
        // 除法擴展
        BigDecimal result5 = bd1.divide(bd2, 4, BigDecimal.ROUND_HALF_UP);// 保留4位小數（採用四捨五入）
        System.out.println("1.0/0.9="+result5);
    }
}
執行結果：
1.0+0.9=1.9
1.0-0.9=0.1
1.0*0.9=0.90
(1.4-0.5)/0.9=1
1.0/0.9=1.1111

Date 類

Date表示特定的瞬間，精確到毫秒。Date類中的大部分方法都已經被Calendar類中的方法所取代。java.util.Date

時間單位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

構造方法：

  • public Date()分配一個 Date對象並對其進行初始化，以便它表示分配的時間，測量到最近的毫秒
  • public Date(long date)分配一個 Date對象，並將其初始化為表示從標準基準時間（稱為「時代」）即1970年1月1日00:00:00 GMT起的指定毫秒數
方法 描述
public boolean after(Date when) 測試此日期是否在指定日期之後
public boolean before(Date when) 測試此日期是否在指定日期之前
public int compareTo(Date anotherDate) 比較兩個日期(如果參數Date等於此Date，則值為0 ; 如果此日期在Date參數之前，該值為-1 ; 如果此日期在Date參數0則值為1）
public boolean equals(Object obj) 比較兩個日期是否等
public long getTime() 返回自1970年1月1日以來，由 Date對象表示的00:00:00 GMT的毫秒 數
public String toString() 將此Date對象轉換為String的形式：
dow mon dd hh:mm:ss zzz yyyy

【演示】

import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        Date today = new Date();// 今天的日期
        System.out.println(today.toString());// toString()方法
        Date yesterday = new Date(today.getTime() - (24*60*60*1000));// 昨天的日期，getTime()方法,(24*60*60*1000)是一天有多少毫秒
        System.out.println(yesterday.toString());
        /*
        after()方法
        before()方法
         */
        boolean flag1 = today.after(yesterday);// today的日期是否在yesterday的日期之後
        System.out.println(flag1);
        boolean flag2 = today.before(yesterday);// today的日期是否在yesterday的日期之前
        System.out.println(flag2);
        /*
        compareTo()方法
        equals()方法
         */
        int a = today.compareTo(yesterday);// today日期在yesterday之前，返回1
        System.out.println(a);
        boolean flag3 = today.equals(yesterday);// 比較today和yesterday日期是否相等
        System.out.println(flag3);
    }
}
執行結果：
Mon Feb 01 12:21:12 CST 2021
Sun Jan 31 12:21:12 CST 2021
true
false
1
false

Calendar類

  • Calendar提供了獲取或設置各種日曆欄位的方法

  • 構造方法 protected Calendar(); 由於是protected 所以無法直接創建

    通過Calendar calendar = Calendar.getInstance();創建對象

方法名 說明
static Calendar getInstance() 使用默認時區和區域獲取日曆
void set(int year, int month, int date, int hourofday, int minute, int second) 設置日曆的年、月、日、時、分、秒
int get(int field) 返回給定日曆欄位的值。欄位比如年、月、日
void setTime(Date date) 用給定的date設置此日曆時間
Date getTime() 返回一個date表示此日曆的時間
void add(int field, int amount) 按照日曆的規則，給指定欄位添加或減少時間量
long getTimeInMilles() 毫秒為單位返回該日曆的時間值
補充：
public int getActualMaximum(int field) 返回指定日曆欄位可能具有的最大值
public int getActualMinimum(int field) 返回指定日曆欄位可能具有的最小值

set()方法,get()方法,setTime()方法,getTime()方法

/* set()方法,get()方法,setTime()方法,getTime()方法 */
import java.util.Calendar;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        Calendar calendar1 = Calendar.getInstance();// 通過調用getInstance()創建對象
        Calendar calendar2 = Calendar.getInstance();
        //calendar2.setTime();
        System.out.println(calendar1.getTime());// getTime()方法
        /*
        獲取時間資訊：年，月，日，時，分，秒
        其中月份0-11,0代表1月，11代表12月
        其中日可以用Calendar.DAY_OF_MONTH，亦可用Calendar.DATE
        其中時：Calendar.HOUR_OF_DAY代表24小時格式，Calendar.HOUR代表12小時格式
         */
        int year = calendar1.get(Calendar.YEAR);// 獲取年
        int month = calendar1.get(Calendar.MONTH);// 獲取月
        int day = calendar1.get(Calendar.DAY_OF_MONTH);// 獲取日
        int hour = calendar1.get(Calendar.HOUR_OF_DAY);// 獲取時
        int minute = calendar1.get(Calendar.MINUTE);// 獲取分
        int second = calendar1.get(Calendar.SECOND);// 獲取秒
        System.out.println("獲取的時間："+year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
        /*
        設置時間：年，月，日，時，分，秒
         */
        calendar2.set(Calendar.YEAR, 2022);//設置年
        calendar2.set(Calendar.MONTH, 5);// 設置月
        calendar2.set(Calendar.DAY_OF_MONTH, 23);// 設置日
        //calendar2.set( 2022, 5, 23);整體設置年月日
        calendar2.set(Calendar.HOUR_OF_DAY, 18);// 設置時
        calendar2.set(Calendar.MINUTE, 45);// 設置分
        calendar2.set(Calendar.SECOND, 5);// 設置秒
        //calendar2.set( 2022, 5, 23, 18, 45,1);整體設置年月日時分秒
        Date date = calendar2.getTime();// getTime()返回一個date表示此日曆的時間
        calendar2.setTime(date);// setTime()用給定的date設置此日曆時間
        System.out.println("設置的時間："+calendar2.getTime());
    }
}
執行結果：
Mon Feb 01 13:32:17 CST 2021
獲取的時間：2021年2月1日13:32:17
設置的時間：Thu Jun 23 18:45:05 CST 2022

add()方法，getTimeInMillis()方法，getActualMaximum（）方法，getActualMinimum（）方法

/* add()方法，getTimeInMillis()方法，
getActualMaximum（）方法，getActualMinimum（）方法
*/
import java.util.Calendar;

public class Demo02 {
    public static void main(String[] args) {
        Calendar calendar1 = Calendar.getInstance();
        System.out.println("初始時間："+calendar1.getTime());
        calendar1.add(Calendar.DAY_OF_MONTH, 2);// 日加2
        calendar1.add(Calendar.HOUR_OF_DAY, -5);// 時減5
        System.out.println("修改後的時間："+calendar1.getTime());
        long x = calendar1.getTimeInMillis();// 返回當前時間為UTC的毫秒數
        System.out.println("當前時間為UTC的毫秒數="+x);
        int max = calendar1.getActualMaximum(Calendar.MONTH);// 月份的最大值為11(月份的範圍是[0, 11]),11代表的就是12月
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);// 日的最小值為1
        System.out.println(max);
        System.out.println(min);
    }
}
執行結果：
初始時間：Mon Feb 01 14:01:55 CST 2021
修改後的時間：Wed Feb 03 09:01:55 CST 2021
當前時間為UTC的毫秒數=1612314115797
11
1

SimpleDateFormat類

  • SimpleDateFormat是一個以與語言環境有關的方式來格式化和解析日期的具體類
  • 進行格式化（日期→文本）、解析（文本→日期）
  • 常用的時間模式字母
字母 日期或時間 示例
y 年 2019
08 年中月份 08
d 月中天數 10
H 一天中小時（0-23） 22
m 分鐘 16
s(小寫) 秒 59
S(大寫) 毫秒 356
方法 描述
public StringBuffer format(Date date,StringBuffer toAppendTo,FieldPosition pos) 將給定的 Date成日期/時間字元串，並將結果附加到給定的 StringBuffer
public Date parse(String text,ParsePosition pos) 從字元串中解析文本以產生一個Date

format()方法和parse方法

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

public class Demo {
    public static void main(String[] args) throws Exception{
        /*
        格式化日期文本（日期-->字元串）
         */
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/DD HH:mm:ss:SS");// 創建對象
        Date date1 = new Date();// 創建date
        String str1 = sdf1.format(date1);// 格式化date1，將日期轉換為字元串
        System.out.println(str1);
        /*
        解析文本日期（字元串-->日期）
         */
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/DD");// 創建對象
        String str2 = "2050/08/12";// 這裡字元串的日期格式必須與上面sdf2設置的格式一致，否則會拋出異常
        Date date2 = sdf2.parse(str2);// 解析str2，將字元串轉換為日期
        System.out.println(date2);
    }
}
執行結果：
2021/02/32 14:35:31:489
Wed Jan 12 00:00:00 CST 2050

特別說明：原因就是parse是一個帶throws 一場的函數，所以如果不在上一級函數也指明拋出異常，或者對parse函數的操作不放在try catch快中，編譯就會出錯

System類

主要用於獲取系統的屬性數據和其他操作，構造方法私有的

方法 描述
static void arraycopy(…) 複製數組
static long currentTimeMillis(); 獲取當前系統時間，返回毫秒值
static void gc(); 建議jvm趕快啟動垃圾回收期器回收垃圾
static void exit(int status); 退出jvm 如果參數是0表示正常退出jvm 非0表示異常退出

public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)

  • src – 源數組

  • srcPos – 源數組中的起始位置

  • dest – 目標數組

  • destPos – 目的地數據中的起始位置

  • length – 要複製的數組元素的數量

arraycopy()方法

public class Demo {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5, 6};// 創建源數組
        int[] array2 = new int[4];// 定義一個目標數組
        System.arraycopy(array1, 1, array2, 0, 3);// 從數組array1中從第1個元素開始複製3個數到數組array2中
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
    }
}
執行結果：
2
3
4
0

currentTimeMillis()

public class Demo02 {
    public static void main(String[] args) {
        long now = System.currentTimeMillis();// 當前時間
        System.out.println(now);
        /*
        擴展：利用System.currentTimeMillis()計時
         */
        long start = System.currentTimeMillis();// StringBuffer()開始時間
        StringBuffer str = new StringBuffer();
        for (int i = 0; i < 99999; i++) {
            str.append(i);
        }
        long end = System.currentTimeMillis();// StringBuffer()結束時間
        System.out.println("StringBuffer用時："+(end - start));
    }
}
執行結果：
1612165446765
StringBuffer用時：11

gc()方法

gc()方法參照本文Object類中的finalize()方法

exit()方法

public class Demo03 {
    public static void main(String[] args) {
        int a = 100;
        System.out.println(a);
        System.exit(0);// 正常退出退出jvm
        System.out.println("**java**");// "**java**"不會被列印
    }
}
執行結果：
100

VirMach 便宜 VPS

QNews

QNews