@目錄

• 內建包裝類
  • JAVA的裝箱與拆箱
    • 裝箱和拆箱
  • Object類
    • toString() 方法
    • equals() 方法
    • getClass() 方法
    • 接收任意引用型別的物件
  • Integer類
    • Integer 類的構造方法
    • Integer 類的常用方法
    • Integer 類的常量
  • Float類
    • Float 類的構造方法
    • Float 類的常用方法
    • Float 類的常用常量
  • Double類
    • Double 類的構造方法
    • Double 類的常用方法
    • Double 類的常用常量
  • Number類
  • Character類
  • Boolean類
    • Boolean 類的構造方法
    • Boolean 類的常用方法
    • Boolean 類的常用常量
  • Byte類
    • Byte 類的構造方法
      • 1. Byte(byte value)
      • 2. Byte(String s)
    • Byte 類的常用方法
    • Byte 類的常用常量
  • System類
    • System 類的成員變數
      • 1. PrintStream out
      • 2. InputStream in
      • 3. PrintStream err
    • System 類的成員方法
      • 1. arraycopy() 方法
      • 2. currentTimeMillis() 方法
      • 3. exit() 方法
      • 4. gc() 方法
      • 5. getProperty() 方法
  • Scanner 類
    • 使用 next 方法：
    • 使用 nextLine 方法：
    • next() 與 nextLine()
    • 其他 型別支援
    • Scanner 小結

內建包裝類

Java 是一種面向物件的程式語言，Java 中的類把方法與資料型別連線在一起，構成了自包含式的處理單元。但在 Java 中不能定義基本型別物件，為了能將基本型別視為物件處理，並能連線相關方法，Java 為每個基本型別都提供了包裝類，如 int 型數值的包裝類 Integer，boolean 型數值的包裝類 Boolean 等。這樣便可以把這些基本型別轉換為物件來處理了。

雖然 Java 可以直接處理基本型別，但是在有些情況下需要將其作為物件來處理，這時就需要將其轉換為包裝類。

JAVA的裝箱與拆箱

在 Java 的設計中提倡一種思想，即一切皆物件。但是從資料型別的劃分中，我們知道 Java 中的資料型別分為基本資料型別和引用資料型別，但是基本資料型別怎麼能夠稱為物件呢？於是 Java 為每種基本資料型別分別設計了對應的類，稱之為包裝類（Wrapper Classes），也有地方稱為外覆類或資料型別類。

包裝類和基本資料型別的關係如下表所示。

我們都知道八種基礎資料型別：byte 、short、int 、long 、char 、float 、double 、boolean

對應的包裝類：Byte 、Short、Integer 、Long 、Character 、Float、Double 、Boolean

我們可以看出，除了 Integer 和 Character 定義的名稱與基本資料型別定義的名稱相差較大外，其它的 6 種類型的名稱都是很好掌握的。

裝箱和拆箱

包裝類的裝箱與拆箱的概念：基本資料型別轉換為包裝類的過程稱為裝箱，例如把 int 包裝成 Integer 類的物件；包裝類變為基本資料型別的過程稱為拆箱，例如把 Integer 類的物件重新簡化為 int。

手動例項化一個包裝類稱為手動拆箱裝箱。Java 1.5 版本之前必須手動拆箱裝箱，之後可以自動拆箱裝箱，也就是在進行基本資料型別和對應的包裝類轉換時，系統將自動進行裝箱及拆箱操作，不用在進行手工操作，為開發者提供了更多的方便。例如：

public class Demo {    
    public static void main(String[] args) {        
        int m = 500;        
        Integer obj = m;  // 自動裝箱        
        int n = obj;  // 自動拆箱        
        System.out.println("n = " + n);              
        Integer obj1 = 500;        
        System.out.println("obj等價於obj1返回結果為" + obj.equals(obj1));    
    }
}

執行結果：

n = 500
obj等價於obj1返回結果為true

自動拆箱裝箱是常用的一個功能，需要重點掌握。

Object類

Object 是 Java 類庫中的一個特殊類，也是所有類的父類。也就是說，Java 允許把任何型別的物件賦給 Object 型別的變數。當一個類被定義後，如果沒有指定繼承的父類，那麼預設父類就是 Object 類。所以Object類是所有JAVA類的根基類，是所有JAVA類的老祖宗。所有的類，不管是誰，都是從它繼承下來的。

因此，以下兩個類表示的含義是一樣的。

public class MyClass{…}

等價於

public class MyClass extends Object {…}

由於 Java 所有的類都是 Object 類的子類，所以任何 Java 物件都可以呼叫 Object 類的方法。常見的方法如下所示。

1. clone 方法：保護方法，實現物件的淺複製，建立與該物件的類相同的新物件
2. getClass方法：final方法，獲得執行時的型別，返回一個物件執行時的例項類
3. toString方法：該方法使用的比較多，一般子類都有覆蓋，返回該物件的字串標示
4. finalize方法：該方法用於釋放資源。當垃圾回收器確定不存在對該物件的更多引用時，物件垃圾回收器呼叫該方法。
5. equals方法：比較兩物件是否相等，一般equals和==是不一樣的，但是在Object中兩者是一樣的。子類一般都要重寫這個方法。
6. hashCode方法：該方法用於雜湊查詢，返回該物件的雜湊碼值，重寫了equals方法一般都要重寫hashCode()方法。
7. wait方法：wait方法就是使當前執行緒等待該物件的鎖，當前執行緒必須是該物件的擁有者，也就是具有該物件的鎖。wait()方法一直等待，直到獲得鎖或者被中斷。wait(long timeout)設定一個超時間隔，如果在規定時間內沒有獲得鎖就返回。 呼叫該方法後當前執行緒進入睡眠狀態，直到以下事件發生。
   1. 其他執行緒呼叫了該物件的notify方法。
   2. 其他執行緒呼叫了該物件的notifyAll方法。
   3. 其他執行緒呼叫了interrupt中斷該執行緒。
   4. 時間間隔到了。

此時該執行緒就可以被排程了，如果是被中斷的話就丟擲一個InterruptedException異常。

8．notify方法：該方法喚醒在該物件上等待的某個執行緒。

9．notifyAll方法：該方法喚醒在該物件上等待的所有執行緒。

其中，toString()、equals() 方法和 getClass() 方法在 Java 程式中比較常用。

toString() 方法

toString() 方法返回該物件的字串，當程式輸出一個物件或者把某個物件和字串進行連線運算時，系統會自動呼叫該物件的 toString() 方法返回該物件的字串表示。

Object 類的 toString() 方法返回“執行時類名@十六進位制雜湊碼”格式的字串，但很多類都重寫了 Object 類的 toString() 方法，用於返回可以表述該物件資訊的字串。

先看以下程式碼：

// 定義Demo類，實際上繼承Object類
class Demo {
    
}

public class ObjectDemo01 {    
    public static void main(String[] args) {        
        Demo d = new Demo(); // 例項化Demo物件        
        System.out.println("不加toString()輸出：" + d);        
        System.out.println("加上toString()輸出：" + d.toString());    
    }
}

輸出結果為：

不加toString()輸出：Demo@15db9742
加上toString()輸出：Demo@15db9742

以上的程式是隨機輸出了一些地址資訊，從程式的執行結果可以清楚的發現，加和不加 toString() 的最終輸出結果是一樣的，也就是說物件輸出時一定會呼叫 Object 類中的 toString() 方法列印內容。所以利用此特性就可以通過 toString() 取得一些物件的資訊，如下面程式碼。

public class Person {    
    private String name;    
    private int age;  
    
    public Person(String name, int age) {        
        this.name = name;        
        this.age = age;    
    }    
    
    public String toString() {        
        return "姓名：" + this.name + "：年齡" + this.age;    
    }    
    
    public static void main(String[] args) {       
        Person per = new Person("測試類", 30);// 例項化Person物件       
        System.out.println("物件資訊：" + per);// 列印物件呼叫toString()方法    
    }
}

輸出結果為：

物件資訊：姓名：測試類：年齡30

程式中的 Person 類中重寫了 Object 類中的 toString() 方法，這樣直接輸出物件時呼叫的是被子類重寫過的 toString() 方法。

equals() 方法

在前面學習字串比較時，曾經介紹過兩種比較方法，分別是==運算子和 equals() 方法，==運算子是比較兩個引用變數是否指向同一個例項，equals() 方法是比較兩個物件的內容是否相等，通常字串的比較只是關心內容是否相等。

其使用格式如下：

boolean result = obj.equals(Object o);

其中，obj 表示要進行比較的一個物件，o 表示另一個物件。

getClass() 方法

getClass() 方法返回物件所屬的類，是一個 Class 物件。通過 Class 物件可以獲取該類的各種資訊，包括類名、父類以及它所實現介面的名字等。

例：編寫一個例項，演示如何對 String 型別呼叫 getClass() 方法，然後輸出其父類及實現的介面資訊。具體實現程式碼如下：

public class Test02 {
    public static void printClassInfo(Object obj) {
        // 獲取類名
        System.out.println("類名：" + obj.getClass().getName());

        // 獲取父類名
        System.out.println("父類：" + obj.getClass().getSuperclass().getName());
        System.out.println("實現的介面有：");

        // 獲取實現的介面並輸出
        for (int i = 0; i < obj.getClass().getInterfaces().length; i++) {
            System.out.println(obj.getClass().getInterfaces()[i]);
        }
    }

    public static void main(String[] args) {
        String strObj = new String();
        printClassInfo(strObj);
    }
}

該程式的執行結果如下：

類名：java.lang.String
父類：java.lang.Object
實現的介面有：
interface java.io.Serializable
interface java.lang.Comparable
interface java.lang.CharSequence

接收任意引用型別的物件

既然 Object 類是所有物件的父類，則所有的物件都可以向 Object 進行轉換，在這其中也包含了陣列和介面型別，即一切的引用資料型別都可以使用 Object 進行接收。

interface A {    
    public String getInfo();
}

class B implements A {    
    public String getInfo() {        
        return "Hello World!!!";    
    }
}

public class ObjectDemo04 {   
    public static void main(String[] args) {        
        // 為介面例項化       
        A a = new B();        
        // 物件向上轉型       
        Object obj = a;        
        // 物件向下轉型        
        A x = (A) obj;       
        System.out.println(x.getInfo());    
    }
}

輸出結果為：

Hello World!!!

通過以上程式碼可以發現，雖然介面不能繼承一個類，但是依然是 Object 類的子類，因為介面本身是引用資料型別，所以可以進行向上轉型操作。

同理，也可以使用 Object 接收一個數組，因為陣列本身也是引用資料型別。

public class ObjectDemo05 {
    public static void main(String[] args) {
        int temp[] = { 1, 3, 5, 7, 9 };
        // 使用object接收陣列
        Object obj = temp;
        // 傳遞陣列引用
        print(obj);
    }

    public static void print(Object o) {
        // 判斷物件的型別
        if (o instanceof int[]) {
            // 向下轉型
            int x[] = (int[]) o;
            // 迴圈輸出
            for (int i = 0; i < x.length; i++) {
                System.out.print(x[i] + "\t");
            }
        }
    }
}

輸出結果為：

1 3 5 7 9

以上程式使用 Object 接收一個整型陣列，因為陣列本身屬於引用資料型別，所以可以使用 Object 接收陣列內容，在輸出時通過 instanceof 判斷型別是否是一個整型陣列，然後進行輸出操作。

提示：因為 Object 類可以接收任意的引用資料型別，所以在很多的類庫設計上都採用 Object 作為方法的引數，這樣操作起來比較方便。

Integer類

Integer 類在物件中包裝了一個基本型別 int 的值。Integer 類物件包含一個 int 型別的欄位。此外，該類提供了多個方法，能在 int 型別和 String 型別之間互相轉換，還提供了處理 int 型別時非常有用的其他一些常量和方法。

Integer 類的構造方法

Integer 類中的構造方法有以下兩個：

• Integer(int value)：構造一個新分配的 Integer 物件，它表示指定的 int 值。
• Integer(String s)：構造一個新分配的 Integer 物件，它表示 String 引數所指示的 int 值。

例如，以下程式碼分別使用以上兩個構造方法來獲取 Integer 物件：

Integer integer1 = new Integer(100);    // 以 int 型變數作為引數建立 
Integer 物件Integer integer2 = new Integer("100");    // 以 String 型變數作為引數建立 Integer 物件

Integer 類的常用方法

在 Integer 類內部包含一些和 int 型別操作有關的方法，表列出了這些常用的方法。

在實際的程式設計過程中，經常將字串轉換為 int 型別的數值，或者將 int 型別的數值轉換為對應的字串。

以下程式碼演示如何實現這兩種功能：

String str = "456";int num = Integer.parseInt(str);    // 將字串轉換為int型別的數值
int i = 789;String s = Integer.toString(i);    // 將int型別的數值轉換為字串

注意：在實現將字串轉換為 int 型別數值的過程中，如果字串中包含非數值型別的字元，則程式執行將出現異常。

Integer 類的常量

Integer 類包含以下 4 個常量。

• MAX_VALUE：值為 2的31次方-1 的常量，它表示 int 型別能夠表示的最大值。
• MIN_VALUE：值為 -2的31次方 的常量，它表示 int 型別能夠表示的最小值。
• SIZE：用來以二進位制補碼形式表示 int 值的位元位數。
• TYPE：表示基本型別 int 的 Class 例項。

下面的程式碼演示了 Integer 類中常量的使用。

int max_value = Integer.MAX_VALUE;    // 獲取 int 型別可取的最大值
int min_value = Integer.MIN_VALUE;    // 獲取 int 型別可取的最小值
int size = Integer.SIZE;    // 獲取 int 型別的二進位制位
Class c = Integer.TYPE;    // 獲取基本型別 int 的 Class 例項

Float類

Float 類在物件中包裝了一個基本型別 float 的值。Float 類物件包含一個 float 型別的欄位。此外，該類提供了多個方法，能在 float 型別與 String 型別之間互相轉換，同時還提供了處理 float 型別時比較常用的常量和方法。

Float 類的構造方法

Float 類中的構造方法有以下 3 個。

• Float(double value)：構造一個新分配的 Float 物件，它表示轉換為 float 型別的引數。
• Float(float value)：構造一個新分配的 Float 物件，它表示基本的 float 引數。
• Float(String s)：構造一個新分配的 Float 物件，它表示 String 引數所指示的 float 值。

例如，以下程式碼分別使用以上 3 個構造方法獲取 Float 物件：

Float float1 = new Float(3.14145);    // 以 double 型別的變數作為引數建立 
Float 物件Float float2 = new Float(6.5);    // 以 float 型別的變數作為引數建立 
Float 物件Float float3 = new Float("3.1415");    // 以 String 型別的變數作為引數建立 Float 物件

Float 類的常用方法

例，將字串 456.7 轉換為 float 型別的數值，或者將 float 型別的數值 123.4 轉換為對應的字串，以下演示如何實現這兩種功能：

String str = "456.7";float num = Float.parseFloat(str);    // 將字串轉換為 float 型別的數值
float f = 123.4f;String s = Float.toString(f);    // 將 float 型別的數值轉換為字串

注意：在實現將字串轉換為 float 型別數值的過程中，如果字串中包含非數值型別的字元，則程式執行將出現異常。

Float 類的常用常量

在 Float 類中包含了很多常量，其中較為常用的常量如下。

• MAX_VALUE：值為 1.4E38 的常量，它表示 float 型別能夠表示的最大值。
• MIN_VALUE：值為 3.4E-45 的常量，它表示 float 型別能夠表示的最小值。
• MAX_EXPONENT:有限 float 變數可能具有的最大指數。
• MIN_EXPONENT：標準化 float 變數可能具有的最小指數。
• MIN_NORMAL：儲存 float 型別數值的最小標準值的常量，即2的-126次方。
• NaN：儲存 float 型別的非數字值的常量。
• SIZE：用來以二進位制補碼形式表示 float 值的位元位數。
• TYPE：表示基本型別 float 的 Class 例項。

下面的程式碼演示了 Float 類中常量的使用。

float max_value = Float.MAX_VALUE;    // 獲取 float 型別可取的最大值
float min_value = Float.MIN_VALUE;    // 獲取 float 型別可取的最小值
float min_normal = Float.MIN_NORMAL;    // 獲取 float 型別可取的最小標準值
float size = Float.SIZE;    // 獲取 float 型別的二進位制位

Double類

Double 類在物件中包裝了一個基本型別 double 的值。Double 類物件包含一個 double 型別的欄位。此外，該類還提供了多個方法，可以將 double 型別與 String 型別相互轉換，同時 還提供了處理 double 型別時比較常用的常量和方法。

Double 類的構造方法

Double 類中的構造方法有如下兩個。

• Double(double value)：構造一個新分配的 Double 物件，它表示轉換為 double 型別的引數。
• Double(String s)：構造一個新分配的 Double 物件，它表示 String 引數所指示的 double 值。

例如，以下程式碼分別使用以上兩個構造方法獲取 Double 物件：

Double double1 = new Double(5.456);    // 以 double 型別的變數作為引數建立 Double 物件
Double double2 = new Double("5.456");       // 以 String 型別的變數作為引數建立 Double 物件

Double 類的常用方法

在 Double 類內部包含一些和 double 操作有關的方法，見表 1。

例如，將字串 56.7809 轉換為 double 型別的數值，或者將 double 型別的數值 56.7809 轉換為對應的字串，以下程式碼實現：

String str = "56.7809";
double num = Double.parseDouble(str);    // 將字串轉換為 double 型別的數值
double d = 56.7809;String s = Double.toString(d);    // 將double型別的數值轉換為字串

在將字串轉換為 double 型別的數值的過程中，如果字串中包含非數值型別的字元，則程式執行將出現異常。

Double 類的常用常量

在 Double 類中包含了很多常量，其中較為常用的常量如下。

• MAX_VALUE:值為 1.8E308 的常量，它表示 double 型別的最大正有限值的常量。
• MIN_VALUE：值為 4.9E-324 的常量，它表示 double 型別資料能夠保持的最小正非零值的常量。
• NaN：儲存 double 型別的非數字值的常量。
• NEGATIVE_INFINITY：保持 double 型別的負無窮大的常量。
• POSITIVE_INFINITY：保持 double 型別的正無窮大的常量。
• SIZE：用秦以二進位制補碼形式表示 double 值的位元位數。
• TYPE：表示基本型別 double 的 Class 例項。

Number類

Number 是一個抽象類，也是一個超類（即父類）。Number 類屬於 java.lang 包，所有的包裝類（如 Double、Float、Byte、Short、Integer 以及 Long）都是抽象類 Number 的子類。

Number 類定義了一些抽象方法，以各種不同數字格式返回物件的值。如 xxxValue() 方法，它將 Number 物件轉換為 xxx 資料型別的值並返回。這些方法如下表所示：

抽象類不能直接例項化，而是必須例項化其具體的子類。如下程式碼演示了 Number 類的使用：

純文字複製
Number num = new Double(12.5);
System.out.println("返回 double 型別的值：" + num.doubleValue());
System.out.println("返回 int 型別的值：" + num.intValue());
System.out.println("返回 float 型別的值：" + num.floatValue());

執行上述程式碼，輸出結果如下：

返回 double 型別的值：12.5
返回 int 型別的值：12
返回 float 型別的值：12.5

Character類

Character 類是字元資料型別 char 的包裝類。Character 類的物件包含型別為 char 的單個欄位，這樣能把基本資料型別當物件來處理，其常用方法如表所示。

可以從 char 值中建立一個 Character 物件。

Character character = new Character('S');

CompareTo() 方法將這個字元與其他字元比較，並且返回一個整型陣列，這個值是兩個字元比較後的標準程式碼差值。當且僅當兩個字元相同時，equals() 方法的返回值才為 true。

Boolean類

Boolean 類將基本型別為 boolean 的值包裝在一個物件中。一個 Boolean 類的物件只包含一個型別為 boolean 的欄位。此外，此類還為 boolean 和 String 的相互轉換提供了很多方法，並提供了處理 boolean 時非常有用的其他一些常用方法。

Boolean 類的構造方法

Boolean 類有以下兩種構造形式：

Boolean(boolean boolValue);
Boolean(String boolString);

其中 boolValue 必須是 true 或 false（不區分大小寫），boolString 包含字串 true（不區分大小寫），那麼新的 Boolean 物件將包含 true；否則將包含 false。

Boolean 類的常用方法

在 Boolean 類內部包含了一些和 Boolean 操作有關的方法，見表。

例如何使用不同的構造方法建立 Boolean 物件，並呼叫 booleanValue() 主法將建立的物件重新轉換為 boolean 資料輸出。程式碼如下：

public class Test05 {
    public static void main(String[] args) {
        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("ok");
        Boolean b3 = new Boolean("true");
        System.out.println("b1 轉換為 boolean 值是：" + b1);
        System.out.println("b2 轉換為 boolean 值是：" + b2);
        System.out.println("b3 轉換為 boolean 值是：" + b3);
    }
}

程式非常簡單，執行後的輸出結果如下：

b1 轉換為 boolean 值是：true
b2 轉換為 boolean 值是：false
b3 轉換為 boolean 值是：true

Boolean 類的常用常量

在 Boolean 類中包含了很多的常量，其中較為常用的常量如下。

• TRUE：對應基值 true 的 Boolean 物件。
• FALSE：對應基值 false 的 Boolean 物件。
• TYPE：表示基本型別 boolean 的 Class 物件。

Byte類

Byte 類將基本型別為 byte 的值包裝在一個物件中。一個 Byte 類的物件只包含一個型別為 byte 的欄位。此外，該類還為 byte 和 String 的相互轉換提供了方法，並提供了一些處理 byte 時非常有用的常量和方法。

Byte 類的構造方法

Byte 類提供了兩個構造方法來建立 Byte 物件。

1. Byte(byte value)

通過這種方法建立的 Byte 物件，可以表示指定的 byte 值。例如，下面的示例將 5 作為 byte 型別變數，然後再建立 Byte 物件。

byte my_byte = 5;
Byte b = new Byte(my_byte);

2. Byte(String s)

通過這個方法建立的 Byte 物件，可表示 String 引數所指定的 byte 值。例如將 5 作為 String 型別變數，然後再建立 Byte 物件。

String my_byte = "5";
Byte b = new Byte(my_byte);

注意：必須使用數值型的 String 變數作為引數才能建立成功，否則會丟擲 NumberFormatException 異常。

Byte 類的常用方法

在 Byte 類內部包含了一些和 Byte 操作有關的方法，見表。

Byte 類的常用常量

在 Byte 類中包含了很多的常量，其中較為常用的常量如下。

• MIN_VALUE：byte 類可取的最小值。
• MAX_VALUE：byte 類可取的最大值。
• SIZE：用於以二進位制補碼形式表示的 byte 值的位數。
• TYPE：表示基本類 byte 的 Class 例項。

System類

System 類位於 java.lang 包，代表當前 Java 程式的執行平臺，系統級的很多屬性和控制方法都放置在該類的內部。由於該類的構造方法是 private 的，所以無法建立該類的物件，也就是無法例項化該類。

System 類提供了一些類變數和類方法，允許直接通過 System 類來呼叫這些類變數和類方法。

System 類的成員變數

System 類有 3 個靜態成員變數，分別是 PrintStream out、InputStream in 和 PrintStream err。

1. PrintStream out

標準輸出流。此流已開啟並準備接收輸出資料。通常，此流對應於顯示器輸出或者由主機環境或使用者指定的另一個輸出目標。

例如，編寫一行輸出資料的典型方式是：

System.out.println(data);

其中，println 方法是屬於流類 PrintStream 的方法，而不是 System 中的方法。

2. InputStream in

標準輸入流。此流已開啟並準備提供輸入資料。通常，此流對應於鍵盤輸入或者由主機環境或使用者指定的另一個輸入源。

3. PrintStream err

標準的錯誤輸出流。其語法與 System.out 類似不需要提供引數就可輸出錯誤資訊。也可以用來輸出使用者指定的其他資訊，包括變數值。

例編寫一個 Java 程式，使用本節介紹的 System 類實現從鍵盤輸入字元並顯示出來。 具體實現程式碼如下：

import java.io.IOException;
public class Test06 {
    public static void main(String[] args) {
        System.out.println("請輸入字元，按回車鍵結束輸入:");
        int c;
        try {
            c = System.in.read();    // 讀取輸入的字元
            while(c != '\r') {    // 判斷輸入的字元是不是回車
                System.out.print((char) c);    // 輸出字元
                c = System.in.read();
            }
        } catch(IOException e) {
            System.out.println(e.toString());
        } finally {
            System.err.println();
        }
    }
}

以上程式碼中，System.in.read() 語句讀入一個字元，read() 方法是 InputStream 類擁有的方法。變數 c 必須用 int 型別而不能用 char 型別，否則會因為丟失精度而導致編譯失敗。

以上的程式如果輸入漢字將不能正常輸出。如果要正常輸出漢字，需要把 System.in 宣告為 InputStreamReader 型別的例項，最終在 try 語句塊中的程式碼為：

InputStreamReader in = new InputStreamReader(System.in, "GB2312");
c = in.read();while(c != '\r') {    
    System.out.print((char) c);    
    c = in.read();
}

如上述程式碼所示，語句 InputStreamReader in=new InputStreamReader(System.in,"GB2312") 宣告一個新物件 in，它從 Reader 繼承而來，此時就可以讀入完整的 Unicode 碼，顯示正常的漢字。

System 類的成員方法

System 類中提供了一些系統級的操作方法，常用的方法有 arraycopy()、currentTimeMillis()、exit()、gc() 和 getProperty()。

1. arraycopy() 方法

該方法的作用是陣列複製，即從指定源陣列中複製一個數組，複製從指定的位置開始，到目標陣列的指定位置結束。該方法的具體定義：

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

其中，src 表示源陣列，srcPos 表示從源陣列中複製的起始位置，dest 表示目標陣列，destPos 表示要複製到的目標陣列的起始位置，length 表示複製的個數。

2. currentTimeMillis() 方法

該方法的作用是返回當前的計算機時間，時間的格式為當前計算機時間與 GMT 時間（格林尼治時間）1970 年 1 月 1 日 0 時 0 分 0 秒所差的毫秒數。一般用它來測試程式的執行時間。例如：

long m = System.currentTimeMillis();

上述語句將獲得一個長整型的數字，該數字就是以差值表達的當前時間。

3. exit() 方法

該方法的作用是終止當前正在執行的 Java 虛擬機器，具體的定義格式如下：

public static void exit(int status)

其中，status 的值為 0 時表示正常退出，非零時表示異常退出。使用該方法可以在圖形介面程式設計中實現程式的退出功能等。

4. gc() 方法

該方法的作用是請求系統進行垃圾回收，完成記憶體中的垃圾清除。至於系統是否立刻回收，取決於系統中垃圾回收演算法的實現以及系統執行時的情況。定義如下：

public static void gc()

5. getProperty() 方法

該方法的作用是獲得系統中屬性名為 key 的屬性對應的值，具體的定義如下：

public static String getProperty(String key)

系統中常見的屬性名以及屬性的說明如表所示。

Scanner 類

java.util.Scanner 是 Java5 的新特徵，可以通過 Scanner 類來獲取使用者的輸入。

下面是建立 Scanner 物件的基本語法：

Scanner s = new Scanner(System.in);

通過 Scanner 類的 next() 與 nextLine() 方法獲取輸入的字串，在讀取前我們一般需要 使用 hasNext 與 hasNextLine 判斷是否還有輸入的資料：

使用 next 方法：

ScannerDemo.java 檔案程式碼：

package com.yeyuliuyun.javaSE.scanner;
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        // 從鍵盤接收資料
        Scanner scan = new Scanner(System.in);
        // next方式接收字串
        System.out.println("next方式接收：");
        // 判斷是否還有輸入
        if (scan.hasNext()) {
            String str1 = scan.next();
            System.out.println("輸入的資料為：" + str1);
        }
        // 凡是IO流的物件要習慣關閉，防止佔用資源
        scan.close();
    }
}

執行以上程式輸出結果為：

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
runoob com
輸入的資料為：runoob

可以看到 com 字串並未輸出，接下來我們看 nextLine。

使用 nextLine 方法：

ScannerDemo.java 檔案程式碼：

package com.yeyuliuyun.javaSE.scanner;
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        // 從鍵盤接收資料
        Scanner scan = new Scanner(System.in);
        // nextLine方式接收字串
        System.out.println("nextLine方式接收：");
        // 判斷是否還有輸入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("輸入的資料為：" + str2);
        }
        scan.close();
    }
}

執行以上程式輸出結果為：

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
runoob com
輸入的資料為：runoob com

可以看到 com 字串輸出。

next() 與 nextLine()

next():

1. 一定要讀取到有效字元後才可以結束輸入。
2. 對輸入有效字元之前遇到的空白，next() 方法會自動將其去掉。
3. 只有輸入有效字元後才將其後面輸入的空白作為分隔符或者結束符。
4. next() 不能得到帶有空格的字串。

nextLine()：

1. 以Enter為結束符,也就是說 nextLine()方法返回的是輸入回車之前的所有字元。
2. 可以獲得空白。

其他 型別支援

如果要輸入 int 或 float 型別的資料，在 Scanner 類中也有支援，但是在輸入之前最好先使用 hasNextXxx() 方法進行驗證，再使用 nextXxx() 來讀取：

ScannerDemo.java 檔案程式碼：

package com.yeyuliuyun.javaSE.scanner;
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 從鍵盤接收資料
        int i = 0;
        float f = 0.0f;
        System.out.print("輸入整數：");
        if (scan.hasNextInt()) {
            // 判斷輸入的是否是整數
            i = scan.nextInt();
            // 接收整數
            System.out.println("整數資料：" + i);
        } else {
            // 輸入錯誤的資訊
            System.out.println("輸入的不是整數！");
        }
        System.out.print("輸入小數：");
        if (scan.hasNextFloat()) {
            // 判斷輸入的是否是小數
            f = scan.nextFloat();
            // 接收小數
            System.out.println("小數資料：" + f);
        } else {
            // 輸入錯誤的資訊
            System.out.println("輸入的不是小數！");
        }
        scan.close();
    }
}

執行以上程式輸出結果為：

$ javac ScannerDemo.java
$ java ScannerDemo
輸入整數：12
整數資料：12
輸入小數：1.2
小數資料：1.2

Scanner 小結

1. java.util.Scanner 是 Java5 的新特徵，通過 Scanner 類來獲取使用者的輸入；
2. Scanner 類的主要方法是 next() 與 nextLine() ,通過 hasNext 與 hasNextLine 判斷是否還有輸入的資料；
3. next() 方法返回的是分隔符或者結束符之前的字元，next() 方法無法得到空格字串，空格 = 分隔符；
4. nextLine() 方法返回的是輸入回車之前的所有字元，可以獲得空白。
5. 對其他資料型別(int,float,double) 要用hasNextXxx() 方法進行驗證，再使用 nextXxx() 來讀取：
6. hasNextXxx() 和 nextXxx() 中的 Xxx 代表資料型別，如：hasNextInt()。